Quiero contar cuántas palabras tiene mi documento LaTeX. Puedo hacer esto yendo al sitio web para el paquete de texcount y usando la interfaz web allí. Pero eso no es ideal.

Prefiero tener un acceso directo dentro de emacs para devolver solo el número de palabras en un archivo (o idealmente el número de palabras en el archivo y en todos los archivos llamados por \inputo \includedentro del documento). He descargado el script de texcount, pero no sé qué hacer con él. Es decir, no sé dónde colocar el .plarchivo y cómo llamarlo dentro de emacs.

Es decir: quiero un atajo de teclado para un comando de shell. Y quiero que ese comando de shell ejecute texcount en el búfer activo actual y devuelva el total de palabras en el minibúfer.

Estoy usando Ubuntu y emacs22, si eso ayuda ...

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

Puede optar por colocar texcount.pl en otro lugar que no sea / usr / local / bin, simplemente modifique el código según corresponda si lo hace. Esto crea un nuevo comando "Mx latex-word-count", que ejecutará texcount.pl en el archivo actual (aunque dará un resultado incorrecto si no ha guardado el archivo). Puede eliminar el punto y coma y reemplazar el texto de relleno con cualquier argumento de línea de comando que desee usar, si lo hay. Puede vincular esto a un comando de teclado con algo como esto en sus .emacs:

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

La página que describe cómo instalar texcount está aquí: texcount faq . Version corta:

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

Aquí hay una versión un poco más agradable del script anterior (maneja espacios en los nombres de archivo, produce una salida de línea, etc.) Los LaTeXganchos son 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)

Version corta: M-! texcount <file.tex> RET

Simplemente usaría emacs incluido, shell-commandque es

M-! <cmd> RET

junto con texcount(texcount.pl) que se instala con la mayoría de las distribuciones de látex. Mientras edita su documento simplemente presione M-!enter texcount <tex-file>y presione regresar.

Una combinación fácil de otras soluciones publicadas aquí sería:

(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 referencia futura, varias de estas respuestas se mejorarían mediante el uso de la función shell-quote-argumentos para garantizar que los espacios y cualquier otro formato divertido en el nombre del archivo se manejen correctamente. Por ejemplo, para mejorar la respuesta 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)

También puedes usar el incorporado M-x tex-count-words. Para hacer un atajo de teclado, agregue lo siguiente a.emacs

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

No sé si esto ayudaría a alguien, pero cuando estaba escribiendo mi tesis quería hacer dos cosas; (1) cuente el número de palabras para toda la tesis (en lugar de un solo capítulo) y (2) use un script de contador personalizado. El punto para este último era que evitaría secciones como resúmenes, declaraciones, etc. y solo seleccionaría los capítulos relevantes.

Cuenta palabras del archivo maestro

La solución aquí era simple; averiguar si el archivo en el que estamos es el maestro, de lo contrario, envíelo 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 un script personalizado

Lo hice agregando una custom-tex-countervariable local al archivo incluido que apuntaba al script bash que era responsable del conteo de palabras.

• Declarar la variable personalizada

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

• Agregue la ruta en las variables locales (final del .texarchivo)

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

• Poniéndolo junto con lo anterior

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

Como referencia, así es como se veía mi script personalizado (no olvide hacer que sea ejecutable):

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

Básicamente, lo único que esto hace es a greplos capítulos y apéndices no comentados del archivo maestro y contar las palabras allí.

Puede cambiar la expresión regular de cada proyecto para que coincida con la estructura que está utilizando, pero, si usa constantemente la misma estructura, puede colocar el script bash en algún lugar de su ruta y convertirlo en una variable global en emacs en lugar de una local.