Como tornar desfazer árvore linear - desfazer árvore desfazer / refazer

10

Ao executar o comando undo-tree-undo/redosucessivamente, as coisas são desfeitas / refeitas com base na ramificação ativa atual. Embora o usuário receba uma mensagem de ponto de ramificação ao longo do caminho, as ramificações anteriores são ignoradas, a menos que um usuário selecione manualmente uma ramificação diferente.

Entendo que posso abrir o visualizador e selecionar um ramo diferente; no entanto, seria muito útil manter pressionada a tecla Desfazer / Refazer e observar tudo acontecer na ordem exatamente oposta. Idealmente, isso deve funcionar independentemente de o visualizerbuffer estar aberto - isto é, calcular programaticamente a ordem do início ao início e do início ao fim.

P : Esta é essencialmente uma solicitação de recurso a ser estendida undo-treepara permitir desfazer / refazer sucessivos lineares, independentemente de o buffer do visualizador estar aberto. [Novas funções e atalhos de teclado alternativos para esse novo recurso são certamente aceitáveis.]

lista de leis
fonte
undo-treeParece que o código faz parte do conceito que você pode alternar livremente entre buffer-undo-treee buffer-undo-listalternando undo-tree-mode. Pelo que entendi sua pergunta, o manuseio original buffer-undo-listfaz o que você deseja. Por isso, sugere-se desligar temporariamente undo-tree-modepara o seu propósito. Lamentavelmente, a alternância entre buffer-undo-treee buffer-undo-listparece ser buggy (pelo menos para mim). Então, talvez, o caminho a seguir seja apenas um relatório de erro para o mantenedor do undo-tree. Mas, talvez meu palpite sobre o conceito original esteja errado.
6117 Tobias
Penso que a melhor solução para o seu problema seria reparar de undo-tree-modeforma a alternar entre buffer-undo-treee buffer-undo-listfuncionar sem falhas. Você já pensou em emitir um relatório de erro em `toby-undo-tree @ dr-qubit.org`?
Tobias
@ Tobias - eu gostaria de ver e usar o visualizador undo-treeenquanto estiver usando o novo linearrecurso; e gostaria que o novo linearrecurso funcionasse sem que o buffer do visualizador estivesse necessariamente visível. Em geral, implementei minhas próprias melhorias / modificações no Emacs, suas bibliotecas de terceiros internas e opcionais. Quando fico preso ou vejo algo super-complexo como o undorecurso, peço ajuda. Uma solicitação de recurso para o mantenedor não poderia prejudicar, mas eu preferiria lidar com isso aqui.
lawlist
@ Tobias - Ao olhar para o undo-tree.elcódigo hoje, vi que existe um recurso de carimbo de data / hora do nó. Não tenho certeza se cada nó tem um carimbo de data / hora válido e se eles sobrevivem para a próxima sessão do Emacs (ao restaurar o histórico), mas parece que pode ser um atalho para resolver essa nova solicitação de recurso - ou seja, classificar e selecionar o anterior ou o próximo no tempo. Ainda não vi a aparência do terreno em um ponto de ramificação, mas ... esses são meus pensamentos preliminares. . . .
lawlist
Eu acho que a chave para uma caminhada linear através da desfazer-árvore é undo-list-rebuild-from-tree. Deve-se letligar a variável buffer-undo-liste deixar undo-list-rebuild-from-treeseu trabalho. Depois copie esse valor para outra variável local, digamos my-undo-list, e deixe o letformulário para ligação buffer-undo-list. A variável my-undo-listdetermina o caminho linear através do undo-tree. Observando undo-list-rebuild-from-treevocê, essa função também usa carimbos de data e hora. Eu pensei anteriormente em usar carimbos de data e hora. Mas tive a impressão de que essas mudanças são frequentes.
23417 Tobias

Respostas:

7

A seguir, é apresentada uma implementação de protótipo de uma aproximação do que você deseja. Explora o fato de que novas ramificações na árvore de desfazer são adicionadas no lado esquerdo do nó atual.

A sequência de teclas C-M-_é vinculada à undo-tree-walkqual caminha a parte superior direita da árvore de desfazer, começando no nó atual.

O comportamento difere do que você deseja se a ramificação ativa de alguma subárvore no lado direito do nó atual não for a ramificação mais à esquerda nessa subárvore.

Você pode entrar nesse estado por meio de seqüências de desfazer / refazer não equivalentes.

Tente você mesmo verificar se isso é suficiente para o seu aplicativo.

(defvar-local undo-tree-walk
  "Possible values:
nil: not in undo/redo-chain
undo: traversing undo tree upwards
redo: traversing undo tree downwards
")

(setq undo-tree-walk nil)

(defun undo-tree-walk ()
  "Walk the right-upper part of the undo-tree starting at the current node."
  (interactive)
  (when (eq buffer-undo-list t)
    (user-error "No undo information."))
  (unless undo-tree-mode
    (user-error "`undo-tree-walk' should only be used with `undo-tree-mode'."))
  (undo-list-transfer-to-tree)
  (set-transient-map undo-tree-walk-map t #'undo-tree-walk-off)
  (let ((num-branches (undo-tree-num-branches)))
    (cond
     ((= num-branches 0) ; arrived at leaf
      (setq undo-tree-walk 'undo))
     ((> num-branches 1) ; 
      (let ((branch (undo-tree-node-branch (undo-tree-current buffer-undo-tree))))
    (setf (undo-tree-node-branch (undo-tree-current buffer-undo-tree))
          (if (>= (1+ branch) (undo-tree-num-branches))
          (progn
            (setq undo-tree-walk 'undo)
            (1- (undo-tree-num-branches)))
        (setq undo-tree-walk 'redo)
        (1+ branch))))
      ;; no state change for (= num-branches 1)
      )
     ))
  (case undo-tree-walk
   (undo
    (undo-tree-undo-1))
   (redo
    (undo-tree-redo-1))
   (t
    (setq undo-tree-walk 'undo)
    (undo-tree-undo-1)))
  (let ((curbuf (current-buffer)))
    (undo-tree-visualize)
    (switch-to-buffer-other-window curbuf)))

(defun undo-tree-walk-off ()
  "Switch `undo-tree-walk' off."
  (setq undo-tree-walk nil))

(defvar undo-tree-walk-map
  (make-sparse-keymap)
  "Keymap active while `undo-tree-walk'.")

(define-key undo-tree-walk-map (kbd "C-M-_") #'undo-tree-walk)

(global-set-key (kbd "C-M-_") #'undo-tree-walk)

Note que eu adicionei undo-tree-visualizeno final de undo-tree-walkpara mostrar as conseqüências de andar pela árvore desfazer undo-tree-walk. Sinta-se livre para modificar o código de acordo com suas preferências.

Observe também que eu tive que escolher essa aproximação mais simples de uma solução para o seu problema devido a restrições de tempo.

Tobias
fonte
Eu adicionei o seguinte ao começo de undo-tree-walkpara passar por alguns erros iniciais, talvez porque eu não tenho esse modo ativo globalmente. (when (eq buffer-undo-list t) (user-error "No undo information.")) (undo-list-transfer-to-tree) Isso silenciou meus erros iniciais em um novo buffer ao tentar esta resposta. Minha próxima observação foi que undo-tree-walkatinge o ponto de ramificação e depois muda para a ramificação à direita, mas apenas desce uma ramificação / nódulo antes de voltar à ramificação para o tronco. Minha configuração preferida cria um entalhe / nódulo para cada toque na tecla.
lawlist
Não há absolutamente nenhuma pressa em uma solução. Sinta-se à vontade para dedicar todo o tempo que você precisar - além do período de recompensa é perfeitamente aceitável. Quando implementado, tenho certeza de que usarei esse recurso diariamente no futuro próximo e, a julgar pelos upvotes até agora, outras pessoas também gostariam de usar esse recurso.
lawlist
@lawlist Infelizmente, meu tempo é restrito. Se fosse possível, eu teria escrito essa resposta mais como um comentário do que como uma resposta. Felizmente, alguém mais inventa algo melhor antes que o período de recompensa termine.
6117 Tobias
@lawlist eu adicionei undo-list-transfer-to-treecomo você propôs. Antes disso, testo se undo-tree-modeestá ativo, caso contrário, undo-list-transfer-to-treepode ser fatal.
Tobias
Premiado recentemente por respostas em tópicos relacionados: emacs.stackexchange.com/a/32415/2287 e emacs.stackexchange.com/a/32416/2287 , pois são os principais ingredientes para implementar o novo recurso. Em poucas palavras, cada nó terá uma lista de carimbos de data / hora - um para cada vez que um nó se torna atual após um desfazer / refazer com êxito e também ao importar inicialmente. Tive uma idéia para visualizar exibindo carimbos de data / hora verticalmente abaixo de cada nó e alongando as ramificações de acordo - levará algum tempo para descobrir programaticamente.
lawlist
3

Agradecimentos especiais a @Tobias por escrever uma função para localizar o carimbo de data / hora seguinte / anterior no histórico de desfazer / refazer: https://emacs.stackexchange.com/a/32415/2287 ; e, também por escrever uma série de funções para copiar a árvore de desfazer: https://emacs.stackexchange.com/a/32230/2287 .

Como alguns leitores já devem saber, os garfos são aceitos pelo MELPA apenas em circunstâncias extremas. A criação de um complemento provavelmente é factível, mas não parece prática, dada a quantidade de alterações feitas pelo @lawlist - incluindo, entre outras, a adição de elementos aos vetores subjacentes da estrutura de dados e a alteração dos nomes de vários funções / variáveis ​​que não estavam em conformidade com a undo-tree-...convenção de nomenclatura do prefixo etc. @lawlist já procurou o autor original (Dr. Cubitt) para oferecer esse novo recurso, além de várias correções e aprimoramentos.

Se alguém estiver interessado, fique à vontade para dar uma olhada nesse novo recurso. O comentário contém um exemplo de formulário de envio de relatório de bug, a partir de emacs -qcaso alguém tenha problemas.

Código fonte:   https://github.com/lawlist/undo_tree

Comentário:

;;; This unofficial modification by @lawlist to the `undo-tree.el` library authored
;;; by Toby Cubitt adds semi-linear undo/redo support and a corresponding visualizer
;;; view accessible with `C-u C-x u` or by using the 3-way toggle with the letter `t`
;;; in the visualization buffer.  This entire library is meant to be a replacement
;;; of the stock version of `undo-tree.el`, which would need to be completely removed
;;; from the `load-path'.  In the visualization buffer, the letters `u` / `r`
;;; or `z` / `Z` are used for semi-linear undo/redo.  In the working buffer,
;;; `super-u` / `super-r` or `super-z`/`super-Z` are used for semi-linear undo/redo.
;;; Semi-linear undo/redo also work in the classic views of the visualization buffer.
;;; All previous keyboard shortcuts remain unchanged.  The mouse can be used to
;;; select semi-linear nodes or branch-point timestamps in the visualization buffer.
;;;
;;; The term `semi-linear` was chosen because the time-line is generally structured
;;; as follows:  When undoing, the movement is in an upward direction from the
;;; leaf to the branch-point and then the previous branch begins undoing from the
;;; leaf.  When redoing, the movement is in a downward direction from the branch-
;;; point to the leaf and then the next branch begins redoing from the branch-point.
;;; It is not a situation where we walk-up and back-down the same branch, or walk-
;;; down and back-up the same branch again.  If that missing feature is useful,
;;; then perhaps it could be implemented someday....
;;;
;;; In a nutshell, the classic version of undo-tree undo/redo limits a user to
;;; the active branch (skipping over inactive branches), unless the user calls
;;; `undo-tree-switch-branch' or `undo-tree-visualize-switch-branch-right' or
;;; `undo-tree-visualize-switch-branch-left' to select an alternative branch.  This
;;; generally means a user must pop-open the visualizer buffer to see what is going
;;; on to make a proper decision.  The new semi-linear feature is essentially
;;; "mindless" where the user can just hold down the forward/reverse button and
;;; go through every node of the tree in chronological order -- i.e., all branches
;;; and nodes are visited in the process (nothing is skipped over).
;;;
;;; The labels in the visualization buffer remain the same:  `o`, `x`, `s`, register.
;;; The branches are labeled consecutively as they are drawn with lowercase letters.
;;; The branch-points are labeled consecutively as they are drawn with uppercase
;;; letters.  The branches coming off of each branch-point are labeled with the nth
;;; numeric position of the branch -- e.g., far left is always nth 0.  The nodes of
;;; each branch are numbered consecutively commencing just after the branch-point.
;;;
;;; The features that are available in `undo-tree.el` version 0.6.6 remain the same;
;;; however, some of the functions have been consolidated and the names have changed.
;;;
;;; `undo-tree-history-save' and `undo-tree-history-restore' support input/output
;;; to/from a string or a file.  The history string/file contains three components:
;;; `buffer-file-name' (if it exists; else `nil`); SHA1 string; the `undo-tree-list'.
;;; Histories created with the unmodified stock version of `undo-tree.el` contained 2
;;; components and those previous versions are no longer supported.  Saving/exporting
;;; excludes all text-properties, yasnippet entries, and multiple-cursors entries.
;;; `read' chokes when encountering #<marker in no buffer> or #<overlay in no buffer>,
;;; that can make their way into the `undo-tree-list' when killing the visualizer
;;; buffer by brute force or when using the yasnippet library.  Those two known
;;; situations have been dealt with programmatically.  However, there are surely
;;; other libraries that use markers and/or overlays that could make their way into
;;; the tree and new ways of dealing with those entries will be required.  If you
;;; encounter an error message when performing `undo-tree-history-save', please
;;; inspect the `*Messages*` buffer for clues such as the above examples.  Inasmuch
;;; as there is now a sanity check at the tail end of `undo-tree-history-save', any
;;; problems should materialize before a user actually tries to restore the history.
;;;
;;; The persistent undo storage has been expanded by adding certain features borrowed
;;; from the built-in `image-dired.el' library:
;;;
;;; `undo-tree-history-autosave':  When non-nil, `undo-tree-mode' will save undo
;;;                                history to a file when a buffer is saved; and,
;;;                                the save/restore functions attached to the
;;;                                following hooks will become active:
;;;                                -  `write-file-functions'
;;;                                -  `find-file-hook'
;;;                                To exclude certain files, users may wish to let-
;;;                                bind this variable to `nil` if it has a global
;;;                                non-nil value.  See also the next variable below.
;;;
;;; `undo-tree-history-file-exclusions':  A list of absolute file names that will be
;;;                                       excluded from the auto save/restore process.
;;;
;;; `undo-tree-history-alist':  Used when `undo-tree-history-storage' is 'classic.
;;;                             See the doc-string for customization tips/tricks.
;;;
;;; `undo-tree-history-directory':  Directory where history files are stored when
;;;                                `undo-tree-history-storage' is 'central.
;;;
;;; `undo-tree-history-storage':  How to store undo-tree history files.
;;;                               'classic:  See `undo-tree-history-alist'.
;;;                               'home (md5):  A folder in the HOME directory.
;;;                               'central (md5):  See `undo-tree-history-directory'.
;;;                               'local:  Create sub-directory in working directory.
;;;
;;; For those users who wish to use Emacs to view the saved/exported history, be
;;; aware that the undo history is one long string, and Emacs has trouble viewing a
;;; buffer with very long lines.  `(setq-default bidi-display-reordering nil)` will
;;; help permit Emacs to view buffers with very long lines without bogging down.
;;;
;;; The primary interactive functions for undo/redo in the working buffer are:
;;;
;;;   M-x undo-tree-classic-undo
;;;   M-x undo-tree-classic-redo
;;;   M-x undo-tree-linear-undo
;;;   M-x undo-tree-linear-redo
;;;
;;; The primary interactive functions for undo/redo in the visualization buffer are:
;;;
;;;   M-x undo-tree-visualize-classic-undo
;;;   M-x undo-tree-visualize-classic-redo
;;;   M-x undo-tree-visualize-linear-undo
;;;   M-x undo-tree-visualize-linear-redo
;;;
;;; If the built-in undo amalgamation business is not to your liking, it can be
;;; disabled to permit undo boundaries after every command:
;;;
;;;   ;;; https://stackoverflow.com/a/41560712/2112489
;;;   (advice-add 'undo-auto--last-boundary-amalgamating-number :override #'ignore)
;;;
;;; https://debbugs.gnu.org/cgi/bugreport.cgi?bug=27214
;;; https://emacs.stackexchange.com/q/33248/2287
;;; GARBAGE COLLECTION:  @lawlist has encountered a few situations where garbage
;;; collection truncates the `undo-tree-canary' in the `buffer-undo-list', which
;;; causes `undo-tree-transfer-list' to replace the existing `undo-tree-list'
;;; with the new tree fragment obtained from the `buffer-undo-list'.  In this
;;; circumstance, the user loses the entire undo-tree saved history!  The internal
;;; function responsible is `truncate_undo_list' in `undo.c`.  @lawlist has added a
;;; programmatic warning when loss of the existing `undo-tree-list' is about to
;;; occur; however, that does not fix the problem.  The relevant section from
;;; `truncate_undo_list' in `undo.c` is as follows:
;;;          /* When we get to a boundary, decide whether to truncate
;;;      either before or after it.  The lower threshold, undo_limit,
;;;      tells us to truncate after it.  If its size pushes past
;;;      the higher threshold undo_strong_limit, we truncate before it.  */
;;;          if (NILP (elt))
;;;     {
;;;       if (size_so_far > undo_strong_limit)
;;;         break;
;;;       last_boundary = prev;
;;;       if (size_so_far > undo_limit)
;;;         break;
;;;     }
;;; @lawlist opines that setting the `undo-limit' to the same value as
;;; `undo-strong-limit' will cause `truncate_undo_list' to preserve the
;;; `undo-tree-canary' in the `buffer-undo-list' by truncating before the boundary.
;;; This workaround is not ideal because a more recent undo would be truncated in
;;; lieu of an older undo.  One idea would be to convince the Emacs team to modify
;;; `truncate_undo_list' to preserve certain user-defined elements; e.g., a symbol
;;; of `undo-tree-canary'.
;;;
;;; The built-in function named `primitive-undo' defined in `simple.el` was used
;;; in the original version of `undo-tree.el`.  @lawlist created a modified
;;; function named `undo-tree--primitive-undo' that serves the same purpose, but
;;; permits setting a window-point in the working buffer while a user is in a
;;; different window such as the visualization buffer.  The revised version also
;;; merely reports a problem with a message instead of throwing an error when it
;;; encounters an `undo-tree-canary' in the wrong location.  This bug was noticed
;;; by @lawlist when performing undo/redo in region, and a Google search revealed
;;; that others too have experienced the same problem.  The bug is fairly easy to
;;; reproduce, but @lawlist has not yet invested the time to look for the cause
;;; and try to come up with a solution.  For anyone who wishes to work on fixing
;;; this and view other mentions of the same problem on the internet, Google:
;;;   "Unrecognized entry in undo list undo-tree-canary"
;;;
;;; The semi-linear visualization buffer view looks like this:
;;;
;;;        o-00001-a-0
;;;        20.34.55.46
;;;             |
;;;        o-br/pt-A-0
;;;        20.47.57.25
;;;        20.34.55.47
;;;         ____|_______________________________
;;;        /                                    \
;;;  o-00001-b-0                            o-00001-c-1
;;;  20.47.57.26                            20.34.55.48
;;;       |                                      |
;;;  o-00002-b-0                            o-00002-c-1
;;;  20.47.57.27                            20.34.55.49
;;;       |                                      |
;;;  o-00003-b-0                            o-00003-c-1
;;;  20.47.57.28                            20.34.55.50
;;;                                              |
;;;                                         o-00004-c-1
;;;                                         20.34.55.51
;;;                                              |
;;;                                         o-br/pt-B-1
;;;                                         21.25.32.05
;;;                                         20.35.06.89
;;;                                         20.35.02.23
;;;                                         20.34.58.43
;;;                                         20.34.55.57
;;;         _____________________________________|________________________
;;;        /            /                        |                        \
;;;  o-00001-d-0  o-00001-e-1               o-br/pt-C-2               o-00001-f-3
;;;  21.25.32.06  20.35.06.90               23.03.45.34               20.34.58.44
;;;                    |                    00.27.40.07                    |
;;;               o-00002-e-1               20.35.02.24               o-00002-f-3
;;;               20.35.06.91         ___________|___________         20.34.58.45
;;;                    |             /           |           \             |
;;;               o-00003-e-1  o-00001-g-0  o-00001-h-1  o-00001-i-2  o-00003-f-3
;;;               20.35.06.92  23.03.45.35  00.27.40.08  20.35.02.25  20.34.58.46
;;;                    |            |            |            |            |
;;;               o-00004-e-1  x-00002-g-0  o-00002-h-1  o-00002-i-2  o-00004-f-3
;;;               20.35.06.93  23:03:45:36  00.27.44.51  20.35.02.26  20.34.58.47
;;;                    |                                      |            |
;;;               o-00005-e-1                            o-00003-i-2  o-00005-f-3
;;;               20.35.06.94                            20.35.02.27  20.34.58.48
;;;                    |                                      |            |
;;;               o-00006-e-1                            o-00004-i-2  o-00006-f-3
;;;               20.35.06.95                            20.35.02.28  20.34.58.49
;;;                    |                                      |            |
;;;               o-00007-e-1                            o-00005-i-2  o-00007-f-3
;;;               20.35.06.96                            20.35.02.29  20.34.58.50
;;;                    |                                      |            |
;;;               o-00008-e-1                            o-00006-i-2  o-00008-f-3
;;;               20.35.06.97                            20.35.02.30  20.34.58.51
;;;
;;; To check for updates, please visit the source-code of the link listed at the
;;; top and also review the "Change Log" at the bottom.
;;;
;;; Bug reports and feature requests may be submitted via email to the address at
;;; the top.  Essentially, if it breaks in half, I can guarantee that you will
;;; have 2 pieces that may not necessarily be the same size.  :)  That being said,
;;; I will certainly make efforts to fix any problem that may arise relating to
;;; the semi-linear undo/redo feature.  A step 1-2-3 recipe starting from emacs -q
;;; would be very helpful so that @lawlist can observe the same behavior described
;;; in the bug report.  Here is an example to get you started:
;;;
;;; 1.  In an internet browser, visit: https://www.lawlist.com/lisp/undo-tree.el
;;;
;;;     Select/highlight all and copy everything to the clipboard.
;;;
;;; 2.  Launch Emacs without any user settings whatsoever:  emacs -q
;;;
;;;     If possible, please use the latest stable public release of Emacs.
;;;     @lawlist is using the GUI version of Emacs 25.2.1 on OSX.
;;;
;;; 3.  Switch to the `*scratch*` buffer.
;;;
;;; 4.  Paste the entire contents of the clpipboard into the `*scratch*` buffer.
;;;
;;; 5.  M-x eval-buffer RET
;;;
;;; 6.  M-x eval-expression RET (setq undo-tree-history-autosave t) RET
;;;
;;; 7.  M-x undo-tree-mode RET
;;;
;;;     The mode-line indicates `UT`, meaning that `undo-tree-mode' is active.
;;;
;;; 8.  M-x save-buffer RET
;;;
;;;     @lawlist chose to save the file to his desktop with the name `foo`, and
;;;     also chose to overwrite the file if it already existed; i.e., `y`.
;;;
;;;     Look at the lower left-hand side of the mode-line and notice that it
;;;     indicates an unmodified state; i.e., U:--- foo ....
;;;
;;; 9.  M-x undo-tree-classic-undo RET
;;;
;;;     Look at the lower left-hand side of the mode-line and notice that it
;;;     indicates we have returned to a modified state; i.e., U:**- foo ....
;;;
;;; 10. M-x undo-tree-classic-undo RET
;;;
;;;     The `undo-tree' library that we had previously pasted to the `*scratch*`
;;;     buffer should now be completely undone; i.e., removed.
;;;
;;; 11. M-x undo-tree-classic-undo RET
;;;
;;;     The buffer should be completely empty at this point; i.e., the initial
;;;     `*scratch*` message has been removed.
;;;
;;; 12. M-x undo-tree-classic-undo RET
;;;
;;;     The following `user-error' appears:
;;;
;;;       "user-error:  undo-tree--undo-or-redo:  No further undo information."
;;;
;;;     This is exactly the behavior that @lawlist expected would happen, so
;;;     everything up to this point appears to be working correctly.
lista de leis
fonte