Como descobrir quantas linhas de código existem em um projeto Xcode?

Existe uma maneira de determinar quantas linhas de código um projeto Xcode contém? Prometo não usar essas informações para medição gerencial ou para fins de benchmarking de funcionários. ;)

Confira o CLOC .

O cloc conta linhas em branco, linhas de comentários e linhas físicas do código fonte em muitas linguagens de programação.

( Compilações herdadas são arquivadas no SourceForge .)

Eu vejo isso flutuando e uso sozinho:

find . "(" -name "*.m" -or -name "*.mm" -or -name "*.cpp" -or -name "*.swift" ")" -print0 | xargs -0 wc -l

Eu tenho usado o CLOC como mencionado porNathan Kinsinger e é bastante fácil de usar. É um script PERL que você pode adicionar e executar no diretório do projeto.

O PERL já faz parte do Mac OS e você pode chamar o script dessa maneira para descobrir o número de linhas que você escreveu:

perl cloc-1.56.pl ./YourDirectoryWhereYourSourcesAre

Este é um exemplo de saída que obtive desse comando:

   176 text files.
   176 unique files.                                          
     4 files ignored.

http://cloc.sourceforge.net v 1.56  T=2.0 s (86.0 files/s, 10838.0 lines/s)
-------------------------------------------------------------------------------
Language                     files          blank        comment           code
-------------------------------------------------------------------------------
Objective C                     80           3848           1876          11844
C/C++ Header                    92            980           1716           1412
-------------------------------------------------------------------------------
SUM:                           172           4828           3592          13256
-------------------------------------------------------------------------------

Abra o Terminal.app, vá para o diretório raiz do seu projeto e execute este comando:

Apenas para Swift:

find . \( -iname \*.swift \) -exec wc -l '{}' \+

Apenas para Obj-C:

find . \( -iname \*.m -o -iname \*.mm -o -iname \*.h \) -exec wc -l '{}' \+

Para Obj-C + Swift:

find . \( -iname \*.m -o -iname \*.mm -o -iname \*.h -o -iname \*.swift \) -exec wc -l '{}' \+

Para Obj-C + Swift + C + C ++:

find . \( -iname \*.m -o -iname \*.mm -o -iname \*.c -o -iname \*.cc -o -iname \*.h -o -iname \*.hh -o -iname \*.hpp -o -iname \*.cpp -o -iname \*.swift \) -exec wc -l '{}' \+

Dicas rápidas sobre o terminal:
ls: listar o conteúdo do diretório
cd: change directory
Pressione a tecla Tab para completar automaticamente
Lembre-se de colocar a barra invertida "\" antes dos espaços
. Sugiro que desative uma pasta do projeto principal para se livrar da contagem de códigos das estruturas

No terminal, mude para o diretório do projeto e execute:

find . -type f -print0 | xargs -0 cat | wc -l

Se você deseja apenas determinados tipos de arquivo, tente algo como

find . -type f -name \*.[ch]* -print0 | xargs -0 cat | wc -l

Confira o Estatístico do Xcode, ele faz exatamente o que você deseja. Ele também fornece outras estatísticas interessantes, portanto vale a pena correr de vez em quando.

Observe que ele não procurará dentro de pastas reais, embora em grupos. É provável que você não esteja usando pastas reais, por isso funcionará muito bem. Se você estiver usando pastas, basta fazer a contagem em cada pasta e adicioná-las.

Nota: Em junho de 2012, parece que isso não funciona corretamente com as versões mais recentes do Xcode.

1. terminal aberto
2. navegue para o seu projeto

3. execute o seguinte comando dentro do seu projeto:

   find . -path ./Pods -prune -o -name "*.swift" -print0 ! -name "/Pods" | xargs -0 wc -l

   Ou:

   find . -path ./Pods -prune -o -name "*[hm]" -print0 ! -name "/Pods" | xargs -0 wc -l

(* Excluindo a contagem de arquivos de pod da contagem total)

Se você for para o diretório do seu projeto no terminal e digite:

find . "(" -name "*.h" -or -name "*.m" -or -name "*.mm" -or -name "*.hpp" -or -name "*.cpp"  -or  -name "*.c" -or -name "*.cc" -or -name "*.swift" ")" -print0 | xargs -0 wc -l

Isso fornecerá uma análise detalhada do projeto, bem como o total de linhas para cada arquivo e o projeto como um todo.

A versão de Nozzi não funciona para mim, mas esta:

find . -type f -print0 | xargs -0 cat | wc -l

Uma maneira rápida e fácil:

Use uma pesquisa regex (Find Navigator, escolha Find> Expressão regular).

. \ n

Funciona de maneira conveniente com os escopos de pesquisa do Xcode e você pode personalizá-lo facilmente para qualquer tipo de linha que queira contar;).

Você pode instalar o SLOCCount através do MacPorts. Ou, mais grosseiramente, você pode usar wc -l.

Não estou familiarizado com o xcode, mas se tudo o que você precisa é contar o número de linhas de todos esses arquivos específicos em uma árvore de diretórios, você pode usar o seguinte comando:

find .... match of all those files ... -exec wc -l {} +

Seguindo a resposta de Joshua Nozzi , no GNU, encontre a expressão regular para esses arquivos:

find . "(" -name "*.m" -or -name "*.mm" -or -name "*.cpp" -or -name "*.swift" ")" -exec wc -l {} +

ou mesmo

find -regex ".*\.\(m\|mm\|cpp\|swift\)$" -exec wc -l {} +

este usa uma expressão regular para coincidir com todos os arquivos que terminam em ambos .m, .mm, .cppou .swift. Você pode ver mais informações sobre essas expressões em Como usar regex na localização de arquivos .

Se você estiver trabalhando com a localização do Mac OS , precisará de uma abordagem um pouco diferente, conforme explicado por Motti Shneor nos comentários:

find -E . -regex ".*\.([hmc]|mm|cp+|swift|pch)$" -exec wc -l {} +

Ambos fornecerão uma saída no formato de:

234 ./file1
456 ./file2
690 total

Portanto, você pode mantê-lo assim ou apenas canalizar tail -1(ou seja find ... | tail -1) para que você obtenha a última linha como sendo o total.

Desculpe por repetir. Essa é a maneira mais fácil IMHO:

1. No tipo de terminal

find /users/<#username#>/documents/folderWithProject/ -type f -exec cp {} /users/<#username#>/documents/folderWithProject/newFolder/ \;

Isso copiará todos os arquivos da pasta do projeto para newFolder.

2. Baixe o Xcode Statistician e use-o comnewFolder

line-counteré uma boa alternativa É mais leve que o CLOC e muito mais poderoso e fácil de usar do que outros comandos.

Uma rápida visão geral

É assim que você obtém a ferramenta

$ pip install line-counter

Use o linecomando para obter a contagem de arquivos e a linha no diretório atual (recursivamente)

$ line
Search in /Users/Morgan/Documents/Example/
file count: 4
line count: 839

Se você quiser mais detalhes, basta usar line -d.

$ line -d
Search in /Users/Morgan/Documents/Example/
Dir A/file C.c                                             72
Dir A/file D.py                                           268
file A.py                                                 467
file B.c                                                   32
file count: 4
line count: 839

E a melhor parte dessa ferramenta é que você pode adicionar .gitignore como o arquivo de configuração. Você pode configurar regras para selecionar ou ignorar que tipo de arquivos contar, exatamente como o que você faz em '.gitignore'. Sim, essa ferramenta foi inventada para facilitar o conhecimento de quantas linhas eu tenho.

Mais descrição e uso estão aqui: https://github.com/MorganZhang100/line-counter

Eu sou o autor desta ferramenta simples. Espero que possa ajudar alguém.