Cuenta el número de líneas en un repositorio git

¿Cómo contaría el número total de líneas presentes en todos los archivos en un repositorio git?

git ls-files me da una lista de archivos rastreados por git.

Estoy buscando un comando para cattodos esos archivos. Algo como

git ls-files | [cat all these files] | wc -l

xargs hará lo que quieras:

git ls-files | xargs cat | wc -l

Pero con más información y probablemente mejor, puede hacer:

git ls-files | xargs wc -l

git diff --stat 4b825dc642cb6eb9a060e54bf8d69288fbee4904

Esto muestra las diferencias del árbol vacío a su árbol de trabajo actual. Lo que sucede para contar todas las líneas en su árbol de trabajo actual.

Para obtener los números en su árbol de trabajo actual, haga esto:

git diff --shortstat `git hash-object -t tree /dev/null`

Te dará una cadena como 1770 files changed, 166776 insertions(+).

Si desea este recuento porque quiere tener una idea del alcance del proyecto, puede preferir la salida de CLOC ("Contar líneas de código"), que le ofrece un desglose de líneas de código significativas e insignificantes por idioma.

cloc $(git ls-files)

(Esta línea es equivalente a git ls-files | xargs cloc. Utiliza shla función de $()sustitución de comandos ).

Salida de muestra:

      20 text files.
      20 unique files.                              
       6 files ignored.

http://cloc.sourceforge.net v 1.62  T=0.22 s (62.5 files/s, 2771.2 lines/s)
-------------------------------------------------------------------------------
Language                     files          blank        comment           code
-------------------------------------------------------------------------------
Javascript                       2             13            111            309
JSON                             3              0              0             58
HTML                             2              7             12             50
Handlebars                       2              0              0             37
CoffeeScript                     4              1              4             12
SASS                             1              1              1              5
-------------------------------------------------------------------------------
SUM:                            14             22            128            471
-------------------------------------------------------------------------------

Tendrás que instalar CLOC primero. Probablemente pueda instalarlo cloccon su administrador de paquetes, por ejemplo, brew install cloccon Homebrew .

cloc $(git ls-files)A menudo es una mejora cloc .. Por ejemplo, la salida de muestra anterior con git ls-filesinformes 471 líneas de código. Para el mismo proyecto, cloc .reporta la friolera de 456,279 líneas (y tarda seis minutos en ejecutarse), porque busca las dependencias en la node_modulescarpeta ignorada de Git .

Me he encontrado con problemas de procesamiento por lotes git ls-files | xargs wc -lal tratar con grandes cantidades de archivos, donde los recuentos de líneas se dividirán en varias totallíneas.

Tomando un consejo de la pregunta ¿Por qué la utilidad wc genera múltiples líneas con "total"? , Encontré el siguiente comando para evitar el problema:

wc -l $(git ls-files)

O si solo desea examinar algunos archivos, por ejemplo, el código:

wc -l $(git ls-files | grep '.*\.cs')

La mejor solución, para mí de todos modos, está enterrada en los comentarios de la respuesta de @ ephemient. Solo lo estoy jalando aquí para que no pase desapercibido. El crédito para esto debe ir a @FRoZeN (y @ephemient).

git diff --shortstat `git hash-object -t tree /dev/null`

devuelve el total de archivos y líneas en el directorio de trabajo de un repositorio, sin ningún ruido adicional. Como beneficio adicional, solo se cuenta el código fuente: los archivos binarios se excluyen de la cuenta.

El comando anterior funciona en Linux y OS X. La versión multiplataforma es

git diff --shortstat 4b825dc642cb6eb9a060e54bf8d69288fbee4904

Eso también funciona en Windows.

Para el registro, las opciones para excluir líneas en blanco,

• -w/ --ignore-all-space,
• -b/ --ignore-space-change,
• --ignore-blank-lines,
• --ignore-space-at-eol

no tiene ningún efecto cuando se usa con --shortstat. Se cuentan las líneas en blanco.

Esto funciona a partir del cloc 1.68:

cloc --vcs=git

Estaba jugando con cmder ( http://gooseberrycreative.com/cmder/ ) y quería contar las líneas de html, css, java y javascript. Si bien algunas de las respuestas anteriores funcionaron, el orpatrón en grep no funcionó: encontré aquí ( /unix/37313/how-do-i-grep-for-multiple-patterns ) que tenía para escapar de ella

Entonces esto es lo que uso ahora:

git ls-files | grep "\(.html\|.css\|.js\|.java\)$" | xargs wc -l

Yo uso lo siguiente:

git grep ^ | wc -l

Esto busca en todos los archivos versionados por git para la expresión regular ^, que representa el comienzo de una línea, por lo que este comando da el número total de líneas.

Hice esto:

git ls-files | xargs file | grep "ASCII" | cut -d : -f 1 | xargs wc -l

esto funciona si cuenta todos los archivos de texto en el repositorio como los archivos de interés. Si algunos se consideran documentación, etc., se puede agregar un filtro de exclusión.

Esta herramienta en github https://github.com/flosse/sloc puede proporcionar la salida de manera más descriptiva. Creará estadísticas de su código fuente:

• lineas fisicas
• líneas de código (fuente)
• líneas con comentarios
• comentarios de una sola línea
• líneas con comentarios de bloque
• líneas mezcladas con fuente y comentarios
• lineas vacias

Tratar:

find . -type f -name '*.*' -exec wc -l {} + 

en el directorio / directorios en cuestión

: | git mktree | git diff --shortstat --stdin

O:

git ls-tree @ | sed '1i\\' | git mktree --batch | xargs | git diff-tree --shortstat --stdin

Dependiendo de si desea o no incluir archivos binarios, hay dos soluciones.

1. git grep --cached -al '' | xargs -P 4 cat | wc -l

2. git grep --cached -Il '' | xargs -P 4 cat | wc -l
   

   "xargs -P 4" significa que puede leer los archivos usando cuatro procesos paralelos. Esto puede ser realmente útil si está escaneando repositorios muy grandes. Dependiendo de la capacidad de la máquina, puede aumentar el número de procesos.

   -a, procesar archivos binarios como texto (Incluir binario)
   -l '', mostrar solo nombres de archivo en lugar de líneas coincidentes (Escanear solo archivos no vacíos)
   -I, no hacer coincidir patrones en archivos binarios (Excluir binario) - en
   caché, buscar en el índice en lugar de en el árbol de trabajo (Incluir archivos no confirmados)