Em um repositório do GitHub, você pode ver "estatísticas do idioma", que exibe a porcentagem do projeto que está escrito em um idioma. No entanto, ele não mostra quantas linhas de código o projeto consiste. Freqüentemente, quero ter uma rápida impressão da escala e complexidade de um projeto, e a contagem de linhas de código pode dar uma boa primeira impressão. 500 linhas de código implica um projeto relativamente simples, 100.000 linhas de código implica um projeto muito grande / complicado.

Portanto, é possível obter as linhas de código escritas nas várias linguagens de um repositório do GitHub, preferencialmente sem cloná-lo?

A pergunta “ Contar número de linhas em um repositório git ” pergunta como contar as linhas de código em um repositório Git local, mas:

1. Você precisa clonar o projeto, que pode ser enorme. A clonagem de um projeto como o Wine, por exemplo, leva séculos.
2. Você contaria linhas em arquivos que não necessariamente seriam código, como arquivos i13n.
3. Se você contar apenas (por exemplo) arquivos Ruby, poderá perder uma quantidade enorme de código em outros idiomas, como JavaScript. Você precisaria saber de antemão quais idiomas o projeto usa. Você também teria que repetir a contagem para todos os idiomas que o projeto usa.

Em suma, isso é potencialmente demorado demais para "verificar rapidamente a escala de um projeto".

Um script de shell, cloc-git

Você pode usar esse script de shell para contar o número de linhas em um repositório Git remoto com um comando:

#!/usr/bin/env bash
git clone --depth 1 "$1" temp-linecount-repo &&
  printf "('temp-linecount-repo' will be deleted automatically)\n\n\n" &&
  cloc temp-linecount-repo &&
  rm -rf temp-linecount-repo

Instalação

Este script requer que o CLOC ("Count Lines of Code") seja instalado. clocprovavelmente pode ser instalado com o seu gerenciador de pacotes - por exemplo, brew install cloccom o Homebrew . Há também uma imagem do docker publicada emmribeiro/cloc .

Você pode instalar o script salvando seu código em um arquivo cloc-git, executando chmod +x cloc-gite movendo o arquivo para uma pasta $PATHcomo a /usr/local/bin.

Uso

O script usa um argumento, que é qualquer URL que git cloneaceitará. Exemplos são https://github.com/evalEmpire/perl5i.git(HTTPS) ou [email protected]:evalEmpire/perl5i.git(SSH). Você pode obter esse URL em qualquer página de projeto do GitHub clicando em "Clonar ou baixar".

Exemplo de saída:

$ cloc-git https://github.com/evalEmpire/perl5i.git
Cloning into 'temp-linecount-repo'...
remote: Counting objects: 200, done.
remote: Compressing objects: 100% (182/182), done.
remote: Total 200 (delta 13), reused 158 (delta 9), pack-reused 0
Receiving objects: 100% (200/200), 296.52 KiB | 110.00 KiB/s, done.
Resolving deltas: 100% (13/13), done.
Checking connectivity... done.
('temp-linecount-repo' will be deleted automatically)


     171 text files.
     166 unique files.                                          
      17 files ignored.

http://cloc.sourceforge.net v 1.62  T=1.13 s (134.1 files/s, 9764.6 lines/s)
-------------------------------------------------------------------------------
Language                     files          blank        comment           code
-------------------------------------------------------------------------------
Perl                           149           2795           1425           6382
JSON                             1              0              0            270
YAML                             2              0              0            198
-------------------------------------------------------------------------------
SUM:                           152           2795           1425           6850
-------------------------------------------------------------------------------

Alternativas

Execute os comandos manualmente

Se você não quiser se preocupar em salvar e instalar o shell script, execute os comandos manualmente. Um exemplo:

$ git clone --depth 1 https://github.com/evalEmpire/perl5i.git
$ cloc perl5i
$ rm -rf perl5i

Linguista

Se você deseja que os resultados correspondam exatamente às porcentagens de idioma do GitHub, tente instalar o Linguist em vez do CLOC . De acordo com o seu README , você precisa gem install linguiste, em seguida, execute linguist. Não consegui fazê-lo funcionar ( edição 2223 ).

Você pode executar algo como

git ls-files | xargs wc -l

que lhe dará a contagem total →

Ou use esta ferramenta → http://line-count.herokuapp.com/

Existe uma extensão para o navegador Google Chrome - GLOC, que funciona para repositórios públicos e privados.

Conta o número de linhas de código de um projeto de:

• página de detalhes do projeto
• repositórios do usuário
• página da organização
• página de resultados de pesquisa
• página de tendências
• explorar a página

Se você for para a página de gráficos / colaboradores, poderá ver uma lista de todos os colaboradores do repositório e quantas linhas foram adicionadas e removidas.

A menos que esteja faltando alguma coisa, subtrair o número agregado de linhas excluídas do número agregado de linhas adicionadas a todos os colaboradores deve gerar o número total de linhas de código no repositório. (EDIT: acontece que estava faltando alguma coisa, afinal. Dê uma olhada no comentário do orbitbot para obter detalhes.)

ATUALIZAR:

Esses dados também estão disponíveis na API do GitHub . Então, escrevi um script rápido para buscar os dados e fazer o cálculo:

'use strict';

function countGithub(repo) {
fetch('https://api.github.com/repos/'+repo+'/stats/contributors')
    .then(response => response.json())
    .then(contributors => contributors
        .map(contributor => contributor.weeks
            .reduce((lineCount, week) => lineCount + week.a - week.d, 0)))
    .then(lineCounts => lineCounts.reduce((lineTotal, lineCount) => lineTotal + lineCount))
    .then(lines => window.alert(lines));
}

countGithub('jquery/jquery'); // or count anything you like

Basta colá-lo em um snippet do Chrome DevTools, alterar o repositório e clicar em executar.

Isenção de responsabilidade (graças a lovasoa ):

Pegue os resultados desse método com um pouco de sal, porque, para alguns repositórios (sorich87 / bootstrap-tour), resulta em valores negativos, o que pode indicar que há algo errado com os dados retornados da API do GitHub.

ATUALIZAR:

Parece que esse método para calcular o número total de linhas não é totalmente confiável. Dê uma olhada no comentário do orbitbot para detalhes.

Você pode clonar apenas o commit mais recente usando git clone --depth 1 <url>e, em seguida, executar sua própria análise usando o Linguist , o mesmo software que o Github usa. Essa é a única maneira que sei que você obterá linhas de código.

Outra opção é usar a API para listar os idiomas que o projeto usa . Não os fornece em linhas, mas em bytes. Por exemplo...

$ curl https://api.github.com/repos/evalEmpire/perl5i/languages
{
  "Perl": 274835
}

Embora leve isso com um pouco de sal, esse projeto inclui YAML e JSON que o site reconhece, mas a API não.

Por fim, você pode usar a pesquisa de código para perguntar quais arquivos correspondem a um determinado idioma. Este exemplo pergunta quais arquivos no perl5i são Perl. https://api.github.com/search/code?q=language:perl+repo:evalEmpire/perl5i. Isso não fornecerá linhas e você precisará solicitar o tamanho do arquivo separadamente, usando o retorno urlde cada arquivo.

No momento, não é possível no Github.com ou em suas APIs.

Conversei com o suporte ao cliente e confirmei que isso não pode ser feito no github.com. Eles passaram a sugestão para a equipe do Github, então espero que seja possível no futuro. Nesse caso, editarei esta resposta.

Enquanto isso, a resposta de Rory O'Kane é uma alternativa brilhante baseada em clocum clone de repositório superficial.

Você pode usar a API do GitHub para obter o sloc como a seguinte função

function getSloc(repo, tries) {

    //repo is the repo's path
    if (!repo) {
        return Promise.reject(new Error("No repo provided"));
    }

    //GitHub's API may return an empty object the first time it is accessed
    //We can try several times then stop
    if (tries === 0) {
        return Promise.reject(new Error("Too many tries"));
    }

    let url = "https://api.github.com/repos" + repo + "/stats/code_frequency";

    return fetch(url)
        .then(x => x.json())
        .then(x => x.reduce((total, changes) => total + changes[1] + changes[2], 0))
        .catch(err => getSloc(repo, tries - 1));
}

Pessoalmente, fiz uma extensão do chrome que mostra o número de SLOC na lista de projetos do github e na página de detalhes do projeto. Você também pode definir seu token de acesso pessoal para acessar repositórios particulares e ignorar o limite de taxa de API.

Você pode fazer o download aqui https://chrome.google.com/webstore/detail/github-sloc/fkjjjamhihnjmihibcmdnianbcbccpnn

O código fonte está disponível aqui https://github.com/martianyi/github-sloc

Complemento do Firefox Github SLOC

Eu escrevi um pequeno addon do firefox que imprime o número de linhas de código nas páginas de projeto do github: Github SLOC

Se a pergunta for "você pode obter rapidamente o NÚMERO DE LINHAS de um repositório no Github", a resposta é não, conforme indicado pelas outras respostas.

No entanto, se a pergunta é "você pode verificar rapidamente a ESCALA de um projeto", geralmente avalio um projeto olhando seu tamanho. É claro que o tamanho incluirá deltas de todas as confirmações ativas, mas é uma boa métrica, pois a ordem de magnitude é bem próxima.

Por exemplo

Qual é o tamanho do projeto "docker"?

No seu navegador, digite api.github.com/repos/ORG_NAME/PROJECT_NAME, ou seja, api.github.com/repos/docker/docker

No hash de resposta, você pode encontrar o atributo size:

{
    ...
    size: 161432,
    ...
}

Isso deve lhe dar uma idéia da escala relativa do projeto. O número parece estar em KB, mas quando o verifiquei no meu computador, ele é realmente menor, embora a ordem de magnitude seja consistente. (161432 KB = 161 MB, janela de encaixe du -s -h = 65 MB)

npm install sloc -g

git clone --depth 1 https://github.com/vuejs/vue/
sloc ".\vue\src" --format cli-table
rm -rf ".\vue\"

Instruções e Explicação

1. Instale o sloc a partir do npm , uma ferramenta de linha de comando (o Node.js. precisa ser instalado).

npm install sloc -g

2. Clone o repositório superficial (download mais rápido que o clone completo).

git clone --depth 1 https://github.com/facebook/react/

3. Execute sloc e especifique o caminho que deve ser analisado.

sloc ".\react\src" --format cli-table

sloc suporta a formatação da saída como a cli-table, as jsonou csv. Expressões regulares podem ser usadas para excluir arquivos e pastas ( Mais informações sobre npm ).

4. Excluir pasta do repositório (opcional)

PowerShell: rm -r -force ".\react\"ou no Mac / Unix:rm -rf ".\react\"

Capturas de tela das etapas executadas (cli-table):

saída sloc (sem argumentos):

Canalize a saída do número de linhas em cada arquivo sortpara organizar os arquivos por contagem de linhas. git ls-files | xargs wc -l |sort -n

No comentário do @ Tgr, há uma ferramenta on-line: https://codetabs.com/count-loc/count-loc-online.html

Abra o terminal e execute o seguinte:

curl https://api.codetabs.com/v1/loc?github=username/reponame