Contagem de palavras para o LaTeX no emacs

Question

Quero contar quantas palavras meu documento LaTeX contém. Eu posso fazer isso indo ao site para o pacote texcount e usando a interface web lá. mas isso não é ideal.

Eu prefiro ter um atalho no emacs para retornar apenas o número de palavras em um arquivo (ou, idealmente, o número de palavras no arquivo e em todos os arquivos chamados por \input ou \include dentro do documento). Eu baixei o script do texcount, mas não sei o que fazer com ele. Ou seja, não sei onde colocar o arquivo .pl e como chamá-lo no emacs.

Ou seja: eu quero um atalho de teclado para um comando shell. E eu quero que o comando shell execute o texcount no buffer ativo atual e retorne o total de palavras no minibuffer.

Estou usando o Ubuntu e o emacs22, se isso ajudar ...

    

Answer 1

%pr_e%

Você pode optar por colocar o texcount.pl em algum lugar diferente de / usr / local / bin, apenas modifique o código conforme apropriado, se preferir. Isto cria um novo comando "M-x latex-word-count", que irá executar texcount.pl no arquivo atual (ele dará o resultado errado se você ainda não salvou o arquivo). Você pode remover o ponto-e-vírgula e substituir o texto de preenchimento por qualquer argumento de linha de comando que deseje usar, se houver. Você pode vincular isso a um comando de teclado com algo assim em seus .emacs:

(define-key latex-mode-map "\C-cw" 'latex-word-count)

A página que descreve como instalar o texcount está aqui: texcount faq . Versão curta: %pr_e% ou alternativamente você pode fazer o que eles recomendam e simplesmente nomeá-lo texcount e atualizar o código apropriadamente.

    

Answer 2

Aqui está uma versão um pouco mais agradável do script acima (trata de espaços em nomes de arquivos, produz saída de uma linha, etc ...) Os LaTeX ganchos são para AuCTeX.

(defun my-latex-setup ()
  (defun latex-word-count ()
    (interactive)
    (let* ((this-file (buffer-file-name))
           (word-count
            (with-output-to-string
              (with-current-buffer standard-output
                (call-process "texcount" nil t nil "-brief" this-file)))))
      (string-match "\n$" word-count)
      (message (replace-match "" nil nil word-count))))
    (define-key LaTeX-mode-map "\C-cw" 'latex-word-count))
(add-hook 'LaTeX-mode-hook 'my-latex-setup t)

    

Answer 3

Uma combinação fácil de outras soluções publicadas aqui seria:

(defun latex-word-count ()
   (interactive)
   (shell-command (concat "texcount " ; my latex installation includes texcount.pl
                       ; "uncomment then options go here, such as "
                       "-unicode "
                       "-inc "
                       (buffer-file-name))) ; better than typing path to current file
)

(define-key LaTeX-mode-map "\C-cw" 'latex-word-count)

    

Answer 4

Para referência futura, várias dessas respostas seriam melhoradas usando a função shell-quote-argument para garantir que os espaços e qualquer outra formatação engraçada no nome do arquivo sejam tratados corretamente. Por exemplo, para melhorar a resposta de plgx:

(defun latex-word-count ()
   (interactive)
   (shell-command (concat "texcount "
                       ; "uncomment then options go here, such as "
                       "-unicode "
                       "-inc "
                       (shell-quote-argument buffer-file-name))) 
;Now the buffer file name is sent correctly to the shell, 
;regardless of platform
)

(define-key LaTeX-mode-map "\C-cw" 'latex-word-count)

    

Answer 5

Versão resumida: M-! texcount <file.tex> RET

Eu simplesmente usaria o emacs incluído shell-command , que é

M-! <cmd> RET

junto com texcount (texcount.pl) que é instalado com a maioria das distribuições de látex. Ao editar o documento, basta acessar M-! enter texcount <tex-file> e clicar em voltar.

    

Answer 6

Você também pode usar o M-x tex-count-words incorporado. Para criar um atalho de teclado, adicione o seguinte a .emacs

(add-hook 'latex-mode-hook
          (lambda () (local-set-key (kbd "C-c C-w") 'tex-count-words)))

    

Answer 7

Eu não sei se isso ajudaria alguém, mas quando eu estava escrevendo minha tese eu queria fazer duas coisas; (1) conte o número de palavras para toda a tese (em vez de um único capítulo) e (2) use um contador personalizado. O ponto para este último é que ele evitaria seções como resumos, declarações, etc. e apenas selecionaria os capítulos relevantes.

Contar palavras do arquivo mestre

A solução aqui foi simples; descubra se o arquivo em que estamos é o principal, caso contrário, envie para texcount .

(defun latex-word-count-master ()
  (interactive)
  (if (eq TeX-master t)
      (setq master (buffer-file-name))
    (setq master (concat (expand-file-name TeX-master) ".tex")))
  (shell-command (concat "texcount "
                         "-dir "
                         "-unicode "
                         "-inc "
                         master)))

Use um script personalizado

Eu fiz isso adicionando uma variável custom-tex-counter local ao arquivo incluído apontando para o script bash que era responsável pela contagem de palavras.

• Declarar a variável personalizada

  (defvar custom-tex-counter nil)
  (make-variable-buffer-local 'custom-tex-counter)
  (put 'custom-tex-counter 'safe-local-variable #'stringp)
  

• Adicione o caminho nas variáveis locais (fim do arquivo .tex )

  %%% Local Variables:
  %%% mode: latex
  %%% TeX-master: "../thesis"
  %%% custom-tex-counter: "../count_words -t"
  %%% End:
  

• Colocando tudo junto com o acima

  (defun latex-word-count-alt ()
    (interactive)
    (if (eq TeX-master t)
        (setq master (buffer-file-name))
      (setq master (concat (expand-file-name TeX-master) ".tex")))
    (if (not (eq custom-tex-counter nil))
        (shell-command (concat custom-tex-counter
                               " "
                               master))
      (shell-command (concat "texcount "
                             "-dir "
                             "-unicode "
                             "-inc "
                             master))))
  

Para referência, veja como ficou meu script personalizado (não esqueça de torná-lo executável):

#!/usr/bin/bash

total='false'

while getopts 't' flag; do
  case "${flag}" in
    t) total='true' ;;
    ?) printf '\nUsage: %s: [-t] \n' $0; exit 2 ;;
  esac
done

shift $(($OPTIND - 1))

TOPATH=$(dirname "${1}")

CHAPTERS=$(while read -r chapter; do
               printf "%s%s.tex\n" "$TOPATH" "/$chapter";
           done < <(grep -Po "^[^%]\s?\include{\K(Chapter|Appendix)[[:digit:]]+/(chapter|appendix)[[:digit:]]+" "${1}") \
           | paste -sd' ')

if [ "$total" == "false" ]; then
    texcount -unicode -inc $CHAPTERS
else
    texcount -unicode -total -inc $CHAPTERS
fi

Basicamente, a única coisa que isso faz é grep dos capítulos e apêndices não comentados do arquivo mestre e contar as palavras lá.

Você pode alterar o regex de cada projeto para corresponder à estrutura que está usando, mas, se usar consistentemente a mesma estrutura, poderá colocar o script em algum lugar do caminho e torná-lo uma variável global no emacs em vez de local um.