Respostas:
xargs
fará o que você quiser:
git ls-files | xargs cat | wc -l
Mas com mais informações e provavelmente melhor, você pode fazer:
git ls-files | xargs wc -l
grep cpp |
lá antes do xargs
, então.
git ls-files -z | xargs -0 wc -l
se você tiver arquivos com espaços no nome.
git ls-files | grep -P ".*(hpp|cpp)" | xargs wc -l
onde a parte grep é qualquer perl regex que você deseja!
git ls-files | grep "\.java$" | xargs wc -l
git diff --stat 4b825dc642cb6eb9a060e54bf8d69288fbee4904
Isso mostra as diferenças da árvore vazia para a sua árvore de trabalho atual. O que acontece para contar todas as linhas da sua árvore de trabalho atual.
Para obter os números na sua árvore de trabalho atual, faça o seguinte:
git diff --shortstat `git hash-object -t tree /dev/null`
Isso lhe dará uma string como 1770 files changed, 166776 insertions(+)
.
git hash-object -t tree /dev/null
.
git diff --stat `git hash-object -t tree /dev/null`
git diff --stat `git hash-object -t tree /dev/null` | tail -1
git diff --shortstat `git hash-object -t tree /dev/null`
para obter a última linha, não é necessário rabo.
Se você deseja essa contagem porque deseja ter uma idéia do escopo do projeto, pode preferir a saída do CLOC ("Count Lines of Code"), que fornece uma descrição detalhada e insignificante de linhas de código por idioma.
cloc $(git ls-files)
(Esta linha é equivalente a git ls-files | xargs cloc
. Ela usa sh
o recurso de $()
substituição de comandos .)
Saída de amostra:
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
-------------------------------------------------------------------------------
Você precisará instalar o CLOC primeiro. Você provavelmente pode instalar cloc
com o seu gerenciador de pacotes - por exemplo, brew install cloc
com o Homebrew .
cloc $(git ls-files)
muitas vezes é uma melhoria cloc .
. Por exemplo, o exemplo de saída acima com git ls-files
relatórios 471 linhas de código. Para o mesmo projeto, cloc .
reporta 456.279 linhas (e leva seis minutos para executar), porque pesquisa as dependências na node_modules
pasta ignorada pelo Git .
cloc --vcs git
esses dias, o que evita alguns casos extremos com arquivos com nomes incorretos (ou muitos deles).
Encontrei problemas em lotes git ls-files | xargs wc -l
ao lidar com um grande número de arquivos, em que a contagem de linhas será dividida em várias total
linhas.
Tomando uma dica da pergunta Por que o utilitário wc gera várias linhas com "total"? , Encontrei o seguinte comando para ignorar o problema:
wc -l $(git ls-files)
Ou se você quiser apenas examinar alguns arquivos, por exemplo, código:
wc -l $(git ls-files | grep '.*\.cs')
wc -l $(git ls-files | find *.m *.h)
wc -l --files0-from=<(git ls-files -z)
. A <(COMMAND)
sintaxe retorna o nome de um arquivo cujo conteúdo é o resultado COMMAND
.
A melhor solução, para mim, está enterrada nos comentários da resposta do @ ephemient. Estou apenas puxando aqui para que não passe despercebido. O crédito para isso deve ir para @FRoZeN (e @ephemient).
git diff --shortstat `git hash-object -t tree /dev/null`
retorna o total de arquivos e linhas no diretório de trabalho de um repositório, sem nenhum ruído adicional. Como bônus, apenas o código-fonte é contado - arquivos binários são excluídos da contagem.
O comando acima funciona no Linux e OS X. A versão multiplataforma dele é
git diff --shortstat 4b825dc642cb6eb9a060e54bf8d69288fbee4904
Isso funciona no Windows também.
Para o registro, as opções para excluir linhas em branco,
-w
/ --ignore-all-space
,-b
/ --ignore-space-change
,--ignore-blank-lines
, --ignore-space-at-eol
não tem nenhum efeito quando usado com --shortstat
. Linhas em branco são contadas.
git mktree </dev/null
ou true|git mktree
ou git mktree <&-
ou :|git mktree
para os contadores de teclas entre nós :-) - uma árvore vazia vazia flutuando em torno do repositório não vai doer nada.
Isso funciona a partir do cloc 1.68:
cloc --vcs=git
--vcs
não funcionou para mim, talvez tenha sido removido. cloc .
enquanto no repositório git funcionou, OTOH.
Eu estava brincando com o cmder ( http://gooseberrycreative.com/cmder/ ) e queria contar as linhas de html, css, java e javascript. Enquanto algumas das respostas acima funcionaram, o or
padrão no grep não - eu encontrei aqui ( /unix/37313/how-do-i-grep-for-multiple-patterns ) que eu tinha escapar disso
Então é isso que eu uso agora:
git ls-files | grep "\(.html\|.css\|.js\|.java\)$" | xargs wc -l
Eu uso o seguinte:
git grep ^ | wc -l
Ele pesquisa todos os arquivos versionados pelo git para o regex ^
, que representa o início de uma linha, portanto, este comando fornece o número total de linhas!
Eu fiz isso:
git ls-files | xargs file | grep "ASCII" | cut -d : -f 1 | xargs wc -l
isso funciona se você contar todos os arquivos de texto no repositório como os arquivos de seu interesse. Se alguns são considerados documentação, etc., um filtro de exclusão pode ser adicionado.
Esta ferramenta no github https://github.com/flosse/sloc pode fornecer a saída de maneira mais descritiva. Ele criará estatísticas do seu código-fonte:
: | git mktree | git diff --shortstat --stdin
Ou:
git ls-tree @ | sed '1i\\' | git mktree --batch | xargs | git diff-tree --shortstat --stdin
Dependendo se você deseja ou não incluir arquivos binários, existem duas soluções.
git grep --cached -al '' | xargs -P 4 cat | wc -l
git grep --cached -Il '' | xargs -P 4 cat | wc -l
"xargs -P 4" significa que pode ler os arquivos usando quatro processos paralelos. Isso pode ser realmente útil se você estiver digitalizando repositórios muito grandes. Dependendo da capacidade da máquina, você pode aumentar o número de processos.
-a, processa arquivos binários como texto (Incluir binário)
-l '', mostra apenas nomes de arquivos em vez de linhas correspondentes (varre apenas arquivos não vazios)
-I, não corresponde a padrões em arquivos binários (Excluir binário)
--cache, procure no índice em vez de na árvore de trabalho (incluir arquivos não confirmados)