Como o emacs conta um incremento de palavras?

Question

Implementando o Método Martini , gostaria de contar o número de palavras adicionadas a um arquivo desde o último ponto de verificação (digamos, todos os dias).

Acho que consegui contar as palavras de uma versão de backup mais antiga, contar as palavras na versão atual e a diferença, mas parece que muito processamento é inútil e há arquivos para gerenciar no caminho.

Existe uma maneira de contar isso no caminho, ou seja, tem uma contagem progressiva que leva em conta todas as entradas e que eu seria capaz de redefinir a qualquer momento?

Eu não me importo de morrer entre as sessões. Eu vejo o yanking como um possível problema, mas principalmente eu não tenho idéia sobre como processar a entrada ao invés de diferenciar arquivos.

    

Answer 1

A seguir, o que eu criei, seguindo as ideias de terdon .

Estou muito feliz com isso, ele faz o que eu queria, em alguns arquivos na variável my-martini-files .

^_Editar: Uma contagem temporária foi adicionada, o que permite empilhar o progresso, e ainda redefinir a contagem às vezes, para não copiar / colar pesado que não deveria adicionar palavras em conta para o progresso alcançado.

Eu o vinculo a f4 para um relatório, C-f4 para reinicializar a contagem (de arquivos), S-f4 para empilhar o progresso e CS-f4 para iniciar um novo dia, todas as contagens a 0.

A fantasia consistiria agora em integrá-la à modelina, mas isso é outro assunto.

;; Teh Martini method
(require 'wc) ; The file terdon links to.
(defun wc-in-buffer (file)
  "Return the number of words in the buffer opening the file
passed as an argument. It should already be open."
  (with-current-buffer (get-file-buffer file)
    (wc-non-interactive (point-min) (point-max)))
  )
(defun my-martini-sum ()
  "Sum words over my-martini-files."
  (apply '+ 
     (loop for file in my-martini-files
        collect (wc-in-buffer file)))
  )
(setq my-martini-files '("~/path/to/file.org"
                         "~/path/to/another/file.org"
                         ;; Taken from org-agenda-files
             ))

(defun my-martini-update () 
  "Update my-martini-count from files."
  (interactive)
  (setq my-martini-count (my-martini-sum))
  (message "Files lengths updated."))
(defun my-martini-reset ()
  "Reset counts and stack for a new day."
  (interactive)
  (my-martini-update)
  (setq my-martini-stack 0)
  (message "Martini counts re-initialized."))
(defun my-martini-stack () 
  "Stack the current progress, and update. 
To be used before pasting loads of unsignificant words."
  (interactive)
  (setq my-martini-stack (+ my-martini-stack (- (my-martini-sum) my-martini-count)))
  (message "Current count is stacked. Mess at will, just update afterwards.")
  )
(defun my-martini-report ()
  "Display changes in total word count since last update."
  (interactive)
  (message (concat "As for now, "
           (number-to-string (+ my-martini-stack (- (my-martini-sum) my-martini-count)))
           " new words have been added today."))
  )
(global-set-key [f4] 'my-martini-report)
(global-set-key [\C-f4] 'my-martini-update)
(global-set-key [\S-f4] 'my-martini-stack)
(global-set-key [\C-\S-f4] 'my-martini-reset)

Quaisquer comentários ou sugestões para melhorar o código são muito bem-vindos.

    

Answer 2

Você deve poder chamar uma função de contagem de palavras na primeira vez que abrir uma sessão do emacs e salvar o resultado em uma variável. Em seguida, você pode executar o comando de contagem de palavras novamente e processar o resultado para obter o número de palavras adicionadas.

Eu dei isso, mas meu emacs-lisp foo é lamentável. Se você é mais conhecedor e confortável com o emacs-lisp do que eu, você deve ser capaz de editar esta função de contagem de palavras para atender às suas necessidades. Por favor, poste de volta aqui se você quiser, eu gostaria de ver como :).

Eu tenho a função e algumas outras informações úteis da página de contagem de palavras do wiki do emacs .

Se uma solução sem emacs for aceitável, você poderá adicionar essas linhas ao seu ~/.bashrc :

function start_count(){
  wc -w $1 | cut -f 1 -d" " > ~/.count; 
  emacs $1
}
function show_progress(){
    p='cat ~/.count'; 
    c='wc -w $1  | cut -f 1 -d" "'; 
    echo "You have written "$(($c-$p))" words today!"
}

Agora, quando você começar a trabalhar, abra o arquivo para edição e salve a contagem de palavras atual em ~/.count da seguinte forma:

start_count file.txt

Quando quiser verificar seu progresso, basta executar:

show_progress file.txt

Lembre-se de que isso tratará as sequências de controle do LaTeX como palavras, portanto, a contagem pode não ser perfeita. Não sei como contornar isso embora ...