Quero contar quantas palavras meu documento LaTeX contém. Eu posso fazer isso acessando o site do pacote texcount e usando a interface da Web. mas isso não é o ideal.

Eu prefiro ter algum atalho no emacs para retornar apenas o número de palavras em um arquivo (ou o número ideal de palavras em um arquivo e em todos os arquivos chamados por \inputou \includedentro do documento). Fiz o download do script texcount, mas não sei o que fazer com ele. Ou seja, não sei onde colocar o .plarquivo e como chamá-lo no emacs.

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

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

(defun latex-word-count ()
  (interactive)
  (shell-command (concat "/usr/local/bin/texcount.pl "
                         ; "uncomment then options go here "
                         (buffer-file-name))))

Você pode colocar o texcount.pl em outro lugar que não seja / usr / local / bin, apenas modifique o código conforme o caso. Isso cria um novo comando "Mx latex-word-count", que executará texcount.pl no arquivo atual (ele fornecerá o resultado errado se você não salvou o arquivo). Você pode remover o ponto-e-vírgula e substituir o texto do preenchimento por qualquer argumento da linha de comando que desejar usar, se houver. Você pode vincular isso a um comando do teclado com algo assim no seu .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:

sudo cp texcount.pl /usr/local/bin/texcount.pl

Aqui está uma versão um pouco mais agradável do script acima (manipula espaços nos nomes de arquivos, produz saída em uma linha, etc ...) Os LaTeXganchos são para o 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)

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

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

M-! <cmd> RET

junto com texcount(texcount.pl), que é instalado com a maioria das distribuições de látex. Durante a edição do documento, basta pressionar M-!Enter texcount <tex-file>e Return.

Uma combinação fácil de outras soluções postadas 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)

Para referência futura, várias dessas respostas seriam aprimoradas 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 manipulados corretamente. Por exemplo, para melhorar a resposta do 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)

Você também pode usar o incorporado M-x tex-count-words. 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)))

Não sei se isso ajudaria alguém, mas quando estava escrevendo minha tese, 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 script de contador personalizado. O ponto principal foi que ele evitaria seções como resumos, declarações etc. e selecionaria apenas os capítulos relevantes.

Contar palavras do arquivo mestre

A solução aqui foi simples; descobrir se o arquivo em que estamos é o principal, caso contrário, envie-o 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

Fiz isso adicionando uma custom-tex-countervariável local ao arquivo incluído, apontando para o script bash, 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 (final do .texarquivo)

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

• Colocando 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 era o meu script personalizado (não se 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 é grepacessar os capítulos e anexos não comentados do arquivo mestre e contar as palavras.

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