Voglio contare quante parole contiene il mio documento LaTeX. Posso farlo andando sul sito web per il pacchetto texcount e usando l'interfaccia web lì. ma non è l'ideale.

Preferirei avere qualche scorciatoia all'interno di emacs per restituire solo il numero di parole in un file (o idealmente il numero di parole nel file e in tutti i file chiamati da \inputo \includeall'interno del documento). Ho scaricato lo script texcount, ma non so cosa farne. Cioè, non so dove mettere il .plfile e come chiamarlo in emacs.

Cioè: voglio una scorciatoia da tastiera per un comando shell. E voglio quel comando shell per eseguire texcount sul buffer attivo corrente e restituire le parole totali nel minibuffer.

Sto usando Ubuntu ed emacs22, se questo aiuta ...

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

Puoi scegliere di mettere texcount.pl in un posto diverso da / usr / local / bin, se lo fai, modifica il codice come appropriato. Questo crea un nuovo comando "Mx latex-word-count", che eseguirà texcount.pl sul file corrente (fornirà il risultato sbagliato se non hai salvato il file). È possibile rimuovere il punto e virgola e sostituire il testo di riempimento con eventuali argomenti della riga di comando che si desidera utilizzare, se presenti. Puoi associarlo a un comando da tastiera con qualcosa del genere nel tuo .emacs:

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

La pagina che descrive come installare texcount è qui: texcount faq . Versione breve:

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

Ecco una versione leggermente più bella dello script sopra (gestisce gli spazi nei nomi dei file, produce un output di una riga, ecc ...) I LaTeXganci sono per 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)

Versione breve: M-! texcount <file.tex> RET

Vorrei semplicemente usare Emacs incluso shell-commandche è

M-! <cmd> RET

insieme a texcount(texcount.pl) che è installato con la maggior parte delle distribuzioni in lattice. Durante la modifica del documento è sufficiente premere M-!Invio texcount <tex-file>e premere Invio .

Una semplice combinazione di altre soluzioni pubblicate qui sarebbe:

(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)

Per riferimento futuro, molte di queste risposte sarebbero migliorate usando la funzione shell-quote-argomento per garantire che gli spazi e qualsiasi altra formattazione divertente nel nome del file fossero gestiti correttamente. Ad esempio, per migliorare la risposta di 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)

Puoi anche usare il built-in M-x tex-count-words. Per creare una scorciatoia da tastiera, aggiungere quanto segue a.emacs

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

Non so se questo avrebbe aiutato nessuno, ma quando stavo scrivendo la mia tesi volevo fare due cose; (1) conta il numero di parole per l'intera tesi (anziché un singolo capitolo) e (2) usa un contatore di script personalizzato. Il punto per quest'ultimo era che avrebbe evitato sezioni come abstract, dichiarazioni, ecc. E avrebbe selezionato solo i capitoli pertinenti.

Conta le parole dal file principale

La soluzione qui era semplice; capire se il file in cui ci troviamo è quello principale, altrimenti inviarlo a 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)))

Usa uno script personalizzato

L'ho fatto aggiungendo una custom-tex-countervariabile locale al file incluso che punta allo script bash che era responsabile del conteggio delle parole.

• Dichiarare la variabile personalizzata

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

• Aggiungi il percorso nelle variabili locali (fine del .texfile)

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

• Mettendolo insieme a quanto sopra

  (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))))
  

Per riferimento ecco come appariva il mio script personalizzato (non dimenticare di renderlo eseguibile):

#!/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

Fondamentalmente, l'unica cosa che fa è per grepi capitoli e le appendici non commentati dal file master e contare le parole lì.

Puoi modificare la regex per ogni progetto in modo che corrisponda alla struttura che stai utilizzando ma, se usi costantemente la stessa struttura, puoi mettere lo script bash da qualche parte nel tuo percorso e trasformarlo in una variabile globale in emacs anziché in una locale.