Sloc Cloc и код (scc)
Инструмент, похожий на cloc, sloccount и tokei. Для подсчета строк кода, пустых строк, строк комментариев и физических строк исходного кода во многих языках программирования.
Цель состоит в том, чтобы быть максимально быстрым счетчиком кода, а также выполнять вычисления COCOMO, такие как Sloccount, оценивать сложность кода, аналогичную калькуляторам цикломатической сложности, и создавать уникальные строки кода или метрики DRYness. Короче говоря, один инструмент, чтобы управлять всеми.
Также у него очень короткое имя, которое легко ввести scc .
Если вам не нравится Sloc Cloc и код, смело используйте имя Succinct Code Counter .
Лицензировано по лицензии MIT.
Оглавление
Поддерживать
Используете scc в коммерческих целях? Если вам нужна приоритетная поддержка для scc вы можете приобрести https://boyter.gumroad.com/l/kgenuv на несколько лет, что дает вам право на приоритетную прямую поддержку по электронной почте от разработчика.
Установить
Перейти к установке
Вы можете установить scc , используя стандартную цепочку инструментов go.
Чтобы установить последнюю стабильную версию scc:
go install github.com/boyter/scc/v3@latest
Чтобы установить версию для разработки:
go install github.com/boyter/scc/v3@master
Обратите внимание, что scc требуется версия go >= 1.22.
Щелчок
Моментальная установка существует благодаря Рикардо.
$ sudo snap install scc
Приложения, установленные NB Snap, не могут работать за пределами /home https://askubuntu.com/questions/930437/permission-denied-error-when-running-apps-installed-as-snap-packages-ubuntu-17, поэтому могут возникнуть проблемы. если вы используете snap и пытаетесь запустить за пределами этого каталога.
Домашнее пиво
Или если у вас установлен Homebrew
$ brew install scc
МакПортс
В macOS вы также можете установить через MacPorts.
$ sudo port install scc
Совок
Или если вы используете Scoop в Windows
$ scoop install scc
Шоколадный
Или если вы используете Chocolatey в Windows
$ choco install scc
WinGet
Или если вы используете WinGet в Windows
winget install --id benboyter.scc --source winget
FreeBSD
Во FreeBSD scc доступен в виде пакета.
$ pkg install scc
Или, если вы предпочитаете собирать из исходного кода, вы можете использовать дерево портов.
$ cd /usr/ports/devel/scc && make install clean
Запустить в Докере
Перейдите в каталог, из которого вы хотите запустить scc.
Запустите команду ниже, чтобы запустить последнюю версию scc в вашем текущем рабочем каталоге:
docker run --rm -it -v "$PWD:/pwd" ghcr.io/lhoupert/scc:master scc /pwd
Руководство
Двоичные файлы для Windows, GNU/Linux и macOS для компьютеров i386 и x86_64 доступны на странице выпусков.
GitLab
https://about.gitlab.com/blog/2023/02/15/code-counting-in-gitlab/
Другой
Если вы хотите помочь с добавлением scc в apt/chocolatey/etc... отправьте запрос или хотя бы поднимите вопрос с инструкциями.
Фон
Прочитайте все о том, как это получилось, а также о тестах производительности,
https://boyter.org/posts/sloc-cloc-code/
https://boyter.org/posts/why-count-lines-of-code/
https://boyter.org/posts/sloc-cloc-code-revisited/
https://boyter.org/posts/sloc-cloc-code- Performance/
https://boyter.org/posts/sloc-cloc-code- Performance-update/
Некоторые отзывы о scc
https://nickmchardy.com/2018/10/counting-lines-of-code-in-koi-cms.html
https://www.feliciano.tech/blog/determine-source-code-size-and-complexity-with-scc/
https://metaredux.com/posts/2019/12/13/counting-lines.html
Доклад о scc , сделанный на первом GopherCon AU (нажмите S, чтобы просмотреть заметки докладчика)
Информацию о производительности смотрите в разделе «Производительность».
Другие подобные проекты,
SLOCCount — исходный счетчик слотов.
cloc, вдохновленный SLOCCount; реализован в Perl для переносимости
gocloc — счетчик слотов в го, вдохновленный токеем
реализация loc Rust аналогична Tokei, но часто быстрее
Реализация loccount Go написана и поддерживается ESR
полиглот счетчик слотов ATS
токей быстрый, точный и написан на ржавчине
счетчик кода sloc Coffeescript
stto новый счетчик кода Go с упором на производительность
Интересное чтение о других проектах подсчета кода: tokei, loc, Polyglot и loccount.
https://www.reddit.com/r/rust/comments/59bm3t/a_fast_cloc_replacement_in_rust/
https://www.reddit.com/r/rust/comments/82k9iy/loc_count_lines_of_code_quickly/
http://blog.vmchale.com/article/polyglot-comparisons
http://esr.ibiblio.org/?p=8270
Дальнейшее чтение об обработке файлов на производительности диска
Использование scc для обработки 40 ТБ файлов из GitHub/Bitbucket/GitLab
Подача
Зачем использовать scc ?
Он очень быстрый и становится быстрее, чем больше процессора вы используете.
Точный
Очень хорошо работает на нескольких платформах без замедления (Windows, Linux, macOS)
Большая языковая поддержка
Может игнорировать дубликаты файлов
Имеет оценки сложности
Вам нужно указать разницу между Coq и Verilog в одном каталоге.
поддержка вывода cloc yaml, поэтому для некоторых пользователей это может стать заменой
Может идентифицировать или игнорировать минифицированные файлы
Способен идентифицировать многие #! файлы ПРОДВИНУТЫ! #115
Может игнорировать большие файлы по строкам или байтам.
Может рассчитать ULOC или уникальные строки кода по файлу, языку или проекту.
Поддерживает несколько выходных форматов для интеграции: CSV, SQL, JSON, HTML и т. д.
Почему бы не использовать scc ?
Различия
Есть некоторые важные различия между scc и другими существующими инструментами. Вот несколько важных моментов, на которые вам стоит обратить внимание.
Пустые строки внутри комментариев считаются комментариями. Хотя технически строка пуста, было принято решение, что все, что находится в комментарии, должно считаться комментарием до тех пор, пока этот комментарий не будет завершен. Таким образом, следующее:
/* blank lines follow
*/
Будет засчитано как 4 строки комментария. Это заметно при сравнении результатов scc с другими инструментами в больших репозиториях.
scc способен правильно считать дословные строки. Например, в C# следующее:
private const string BasePath = @"a:";
// The below is returned to the user as a version
private const string Version = "1.0.0";
Из-за префикса @ эта строка заканчивается на завершающем знаке ", игнорируя escape-символ, и поэтому должна считаться как 2 строки кода и 1 комментарий. Некоторые инструменты не могут справиться с этим и вместо этого считают до "1.0.0". как строку, которая может привести к тому, что средний комментарий будет считаться кодом, а не комментарием.
scc также сообщит вам количество обработанных байтов (для большинства выходных форматов), что позволит вам оценить стоимость запуска некоторых инструментов статического анализа.
Использование
Использование scc в командной строке сделано максимально простым. Полную информацию можно найти в scc --help или scc -h . Обратите внимание, что приведенное ниже состояние соответствует основному состоянию, а не выпуску, поскольку перечисленные ниже функции могут отсутствовать в вашей установке.
Sloc, Cloc and Code. Count lines of code in a directory with complexity estimation.
Version 3.5.0 (beta)
Ben Boyter + Contributors
Usage:
scc [flags] [files or directories]
Flags:
--avg-wage int average wage value used for basic COCOMO calculation (default 56286)
--binary disable binary file detection
--by-file display output for every file
-m, --character calculate max and mean characters per line
--ci enable CI output settings where stdout is ASCII
--cocomo-project-type string change COCOMO model type [organic, semi-detached, embedded, "custom,1,1,1,1"] (default "organic")
--count-as string count extension as language [e.g. jsp:htm,chead:"C Header" maps extension jsp to html and chead to C Header]
--count-ignore set to allow .gitignore and .ignore files to be counted
--currency-symbol string set currency symbol (default "$")
--debug enable debug output
--directory-walker-job-workers int controls the maximum number of workers which will walk the directory tree (default 8)
-a, --dryness calculate the DRYness of the project (implies --uloc)
--eaf float the effort adjustment factor derived from the cost drivers (1.0 if rated nominal) (default 1)
--exclude-dir strings directories to exclude (default [.git,.hg,.svn])
-x, --exclude-ext strings ignore file extensions (overrides include-ext) [comma separated list: e.g. go,java,js]
-n, --exclude-file strings ignore files with matching names (default [package-lock.json,Cargo.lock,yarn.lock,pubspec.lock,Podfile.lock,pnpm-lock.yaml])
--file-gc-count int number of files to parse before turning the GC on (default 10000)
--file-list-queue-size int the size of the queue of files found and ready to be read into memory (default 8)
--file-process-job-workers int number of goroutine workers that process files collecting stats (default 8)
--file-summary-job-queue-size int the size of the queue used to hold processed file statistics before formatting (default 8)
-f, --format string set output format [tabular, wide, json, json2, csv, csv-stream, cloc-yaml, html, html-table, sql, sql-insert, openmetrics] (default "tabular")
--format-multi string have multiple format output overriding --format [e.g. tabular:stdout,csv:file.csv,json:file.json]
--gen identify generated files
--generated-markers strings string markers in head of generated files (default [do not edit,])
-h, --help help for scc
-i, --include-ext strings limit to file extensions [comma separated list: e.g. go,java,js]
--include-symlinks if set will count symlink files
-l, --languages print supported languages and extensions
--large-byte-count int number of bytes a file can contain before being removed from output (default 1000000)
--large-line-count int number of lines a file can contain before being removed from output (default 40000)
--min identify minified files
-z, --min-gen identify minified or generated files
--min-gen-line-length int number of bytes per average line for file to be considered minified or generated (default 255)
--no-cocomo remove COCOMO calculation output
-c, --no-complexity skip calculation of code complexity
-d, --no-duplicates remove duplicate files from stats and output
--no-gen ignore generated files in output (implies --gen)
--no-gitignore disables .gitignore file logic
--no-gitmodule disables .gitmodules file logic
--no-hborder remove horizontal borders between sections
--no-ignore disables .ignore file logic
--no-large ignore files over certain byte and line size set by large-line-count and large-byte-count
--no-min ignore minified files in output (implies --min)
--no-min-gen ignore minified or generated files in output (implies --min-gen)
--no-scc-ignore disables .sccignore file logic
--no-size remove size calculation output
-M, --not-match stringArray ignore files and directories matching regular expression
-o, --output string output filename (default stdout)
--overhead float set the overhead multiplier for corporate overhead (facilities, equipment, accounting, etc.) (default 2.4)
-p, --percent include percentage values in output
--remap-all string inspect every file and remap by checking for a string and remapping the language [e.g. "-*- C++ -*-":"C Header"]
--remap-unknown string inspect files of unknown type and remap by checking for a string and remapping the language [e.g. "-*- C++ -*-":"C Header"]
--size-unit string set size unit [si, binary, mixed, xkcd-kb, xkcd-kelly, xkcd-imaginary, xkcd-intel, xkcd-drive, xkcd-bakers] (default "si")
--sloccount-format print a more SLOCCount like COCOMO calculation
-s, --sort string column to sort by [files, name, lines, blanks, code, comments, complexity] (default "files")
--sql-project string use supplied name as the project identifier for the current run. Only valid with the --format sql or sql-insert option
-t, --trace enable trace output (not recommended when processing multiple files)
-u, --uloc calculate the number of unique lines of code (ULOC) for the project
-v, --verbose verbose output
--version version for scc
-w, --wide wider output with additional statistics (implies --complexity)
Вывод для проекта Redis должен выглядеть примерно так, как показано ниже.
$ scc redis
───────────────────────────────────────────────────────────────────────────────
Language Files Lines Blanks Comments Code Complexity
───────────────────────────────────────────────────────────────────────────────
C 296 180267 20367 31679 128221 32548
C Header 215 32362 3624 6968 21770 1636
TCL 143 28959 3130 1784 24045 2340
Shell 44 1658 222 326 1110 187
Autoconf 22 10871 1038 1326 8507 953
Lua 20 525 68 70 387 65
Markdown 16 2595 683 0 1912 0
Makefile 11 1363 262 125 976 59
Ruby 10 795 78 78 639 116
gitignore 10 162 16 0 146 0
YAML 6 711 46 8 657 0
HTML 5 9658 2928 12 6718 0
C++ 4 286 48 14 224 31
License 4 100 20 0 80 0
Plain Text 3 185 26 0 159 0
CMake 2 214 43 3 168 4
CSS 2 107 16 0 91 0
Python 2 219 12 6 201 34
Systemd 2 80 6 0 74 0
BASH 1 118 14 5 99 31
Batch 1 28 2 0 26 3
C++ Header 1 9 1 3 5 0
Extensible Styleshe… 1 10 0 0 10 0
Smarty Template 1 44 1 0 43 5
m4 1 562 116 53 393 0
───────────────────────────────────────────────────────────────────────────────
Total 823 271888 32767 42460 196661 38012
───────────────────────────────────────────────────────────────────────────────
Estimated Cost to Develop (organic) $6,918,301
Estimated Schedule Effort (organic) 28.682292 months
Estimated People Required (organic) 21.428982
───────────────────────────────────────────────────────────────────────────────
Processed 9425137 bytes, 9.425 megabytes (SI)
───────────────────────────────────────────────────────────────────────────────
Обратите внимание, что вам не нужно указывать каталог, в котором вы хотите запустить. Запуск scc предполагает, что вы хотите работать с текущим каталогом.
Вы также можете запустить несколько файлов или каталогов scc directory1 directory2 file1 file2 результаты которого будут объединены в выходные данные.
Поскольку scc записывает данные в стандартный вывод, существует множество способов легко поделиться результатами. Например, использование netcat и одного из множества вставок дает общедоступный URL-адрес:
$ scc | nc paste.c-net.org 9999
https://paste.c-net.org/Example
Игнорировать файлы
scc в основном поддерживает файлы .ignore внутри сканируемых каталогов. Это похоже на то, как работают ripgrep, ag и tokei. Файлы .ignore на 100% аналогичны файлам .gitignore с тем же синтаксисом, и поэтому scc будет игнорировать файлы и каталоги, перечисленные в них. Вы можете добавить файлы .ignore, чтобы игнорировать такие вещи, как проверенные в файлах зависимости от поставщиков и тому подобное. Идея состоит в том, чтобы вы могли добавить файл или папку в git и игнорировать их при подсчете.
Он также поддерживает собственный файл игнорирования .sccignore если вы хотите, чтобы scc игнорировал некоторые вещи, в то время как ripgrep, ag, tokei и другие поддерживают их.
Интересные случаи использования
Используется внутри гипервизора Intel Nemu для отслеживания изменений кода между версиями https://github.com/intel/nemu/blob/topic/virt-x86/tools/cloc-change.sh#L9. Похоже, что также используется внутри обоих http:/ /codescoop.com/ https://pinpoint.com/ https://github.com/chaoss/grimoirelab-graal
Он также используется для подсчета кода и определения языковых типов на https://searchcode.com/, что делает его одним из наиболее часто запускаемых счетчиков кода в мире.
Вы также можете подключить scc к своему конвейеру gitlab https://gitlab.com/guided-explorations/ci-cd-plugin-extensions/ci-cd-plugin-extension-scc.
Также используется CodeQL #317 и Scaleway https://twitter.com/Scaleway/status/1488087029476995074?s=20&t=N2-z6O-ISDdDzULg4o4uVQ
Функции
scc использует небольшой конечный автомат, чтобы определить, в каком состоянии находится код, когда он достигает новой строки n . Таким образом, он осознает и способен рассчитывать
Благодаря этому он может точно определить, находится ли комментарий в строке или на самом деле является комментарием.
Он также пытается подсчитать сложность кода. Это делается путем проверки операций ветвления в коде. Например, каждое из следующих значений for if switch while else || && != == если встречается в Java, сложность файлов увеличивается на единицу.
Оценки сложности
Давайте уделим минуту обсуждению самой оценки сложности.
Оценка сложности на самом деле представляет собой просто число, которое можно сравнить только с файлами на том же языке. Его не следует использовать для прямого сравнения языков без их взвешивания. Причина этого в том, что он рассчитывается путем поиска операторов ветвления и цикла в коде и увеличения счетчика для этого файла.
Поскольку в некоторых языках нет циклов и вместо них используется рекурсия, их сложность может быть ниже. Означает ли это, что они менее сложны? Вероятно, нет, но инструмент не может этого увидеть, поскольку он не создает AST кода, а только сканирует его.
Как правило, сложность нужна для оценки проектов, написанных на одном и том же языке, или для поиска самого сложного файла в проекте scc --by-file -s complexity , которая может быть полезна, когда вы оцениваете, насколько сложно что-то сделать. support или при поиске тех файлов, которые, вероятно, следует рефакторить.
Что касается того, как это работает.
Это мое собственное определение, но оно пытается приблизиться к цикломатической сложности https://en.wikipedia.org/wiki/Cyclomatic_complexity, хотя и делается только на уровне файла.
Причина, по которой это приближение, заключается в том, что оно вычисляется почти бесплатно с точки зрения процессора (поскольку это дешевый поиск при подсчете), тогда как для реального подсчета цикломатической сложности потребуется анализировать код. На практике это дает разумное предположение, даже если оно не может идентифицировать рекурсивные методы. Цель никогда не заключалась в том, чтобы это было точно.
Короче говоря, когда scc просматривает то, что он определил как код, и если он замечает, что обычно является условием ветвления, он увеличивает счетчик.
Условия, которые он ищет, скомпилированы в код, и вы можете получить представление о них, просмотрев JSON внутри репозитория. См. https://github.com/boyter/scc/blob/master/languages.json#L3869, где приведен пример того, что он ищет в файле Java.
Приращение происходит для каждого из условий соответствия и дает число, которое вы видите.
Уникальные строки кода (ULOC)
ULOC означает «Уникальные строки кода» и представляет собой уникальные строки на разных языках, в файлах и в самом проекте. Эта идея была взята из https://cmcenroe.me/2018/12/14/uloc.html, где расчет представлен с использованием стандартных инструментов Unix sort -u *.h *.c | wc -l . Эта метрика предназначена для помощи в оценке сложности проекта. Цитирую источник
По моему мнению, полученное число должно лучше оценивать сложность проекта. По сравнению с SLOC не учитываются не только пустые строки, но и строки в скобках и другой повторяющийся код, такой как общие включения. С другой стороны, ULOC подсчитывает комментарии, которые требуют такого же тщательного обслуживания, как и код вокруг них, избегая при этом увеличения результата заголовками лицензий, которые появляются, например, в каждом файле.
Вы можете получить ULOC, указав аргумент -u или --uloc для scc .
Он имеет соответствующую метрику DRYness % , которая представляет собой процентное соотношение ULOC к CLOC или DRYness = ULOC / SLOC . Чем выше число, тем более СУХИМ (не повторяйтесь) можно считать проект. В общем, чем выше значение, тем лучше, поскольку оно указывает на меньшее количество дублируемого кода. Метрика DRYness была взята из комментария minimax https://lobste.rs/s/has9r7/uloc_unique_lines_code
Чтобы получить метрику DRYness, вы можете использовать аргумент -a или --dryness для scc , который неявно установит --uloc .
Обратите внимание, что при вычислении метрик ULOC снижается производительность, что может привести к удвоению времени выполнения.
Выполнение вычислений uloc и DRYness на основе кода C клона redis дает следующий результат.
$ scc -a -i c redis
───────────────────────────────────────────────────────────────────────────────
Language Files Lines Blanks Comments Code Complexity
───────────────────────────────────────────────────────────────────────────────
C 419 241293 27309 41292 172692 40849
(ULOC) 133535
───────────────────────────────────────────────────────────────────────────────
Total 419 241293 27309 41292 172692 40849
───────────────────────────────────────────────────────────────────────────────
Unique Lines of Code (ULOC) 133535
DRYness % 0.55
───────────────────────────────────────────────────────────────────────────────
Estimated Cost to Develop (organic) $6,035,748
Estimated Schedule Effort (organic) 27.23 months
Estimated People Required (organic) 19.69
───────────────────────────────────────────────────────────────────────────────
Processed 8407821 bytes, 8.408 megabytes (SI)
───────────────────────────────────────────────────────────────────────────────
Дополнительную информацию о расчете ULOC можно найти по адресу https://boyter.org/posts/sloc-cloc-code-new-metic-uloc/.
КОКОМО
Статистику COCOMO, отображаемую в нижней части любого запуска командной строки, можно настроить по мере необходимости.
Estimated Cost to Develop (organic) $664,081
Estimated Schedule Effort (organic) 11.772217 months
Estimated People Required (organic) 5.011633
Чтобы изменить параметры COCOMO, вы можете использовать одну из моделей COCOMO по умолчанию.
scc --cocomo-project-type organic
scc --cocomo-project-type semi-detached
scc --cocomo-project-type embedded
Вы также можете указать свои собственные параметры, если вы знакомы с COCOMO, следующим образом:
scc --cocomo-project-type "custom,1,1,1,1"
Подробную информацию о том, как выбираются модели, и какие параметры они используют, смотрите ниже.
Органический. Программный проект считается органичным, если требуемый размер команды достаточно мал, проблема хорошо понята и решена в прошлом, а также члены команды имеют номинальный опыт решения этой проблемы.
scc --cocomo-project-type "organic,2.4,1.05,2.5,0.38"
Полуавтономный. Программный проект считается полуавтономным, если его жизненно важные характеристики, такие как размер команды, опыт, знание различных сред программирования, лежат между характеристиками органического и встроенного. Проекты, классифицированные как двухквартирные, сравнительно менее знакомы и сложны в разработке по сравнению с органическими проектами и требуют большего опыта, лучшего руководства и творчества. Например: компиляторы или различные встроенные системы можно считать полуавтономными.
scc --cocomo-project-type "semi-detached,3.0,1.12,2.5,0.35"
Встроенное — в эту категорию подпадает программный проект, требующий высочайшего уровня сложности, креативности и опыта. Такое программное обеспечение требует большего размера команды, чем две другие модели, а также разработчики должны быть достаточно опытными и творческими для разработки таких сложных моделей.
scc --cocomo-project-type "embedded,3.6,1.20,2.5,0.32"
Обнаружение больших файлов
Вы можете настроить scc для исключения больших файлов из вывода.
Для этого можно использовать --no-large , который по умолчанию исключает файлы размером более 1 000 000 байт или 40 000 строк.
Вы можете контролировать размер любого значения, используя --large-byte-count или --large-line-count .
Например, чтобы исключить файлы размером более 1000 строк и размером 50 КБ, вы можете использовать следующее:
scc --no-large --large-byte-count 50000 --large-line-count 1000
Обнаружение минимизированных/сгенерированных файлов
Вы можете указать scc идентифицировать и при необходимости удалить файлы, определенные как минимизированные или сгенерированные из выходных данных.
Вы можете сделать это, включив флаг -z , например scc -z , который будет идентифицировать любой файл со средним размером строки >= 255 (по умолчанию) как минифицированный.
Минимизированные файлы выглядят вот так на выходе.
$ scc --no-cocomo -z ./examples/minified/jquery-3.1.1.min.js
───────────────────────────────────────────────────────────────────────────────
Language Files Lines Blanks Comments Code Complexity
───────────────────────────────────────────────────────────────────────────────
JavaScript (min) 1 4 0 1 3 17
───────────────────────────────────────────────────────────────────────────────
Total 1 4 0 1 3 17
───────────────────────────────────────────────────────────────────────────────
Processed 86709 bytes, 0.087 megabytes (SI)
───────────────────────────────────────────────────────────────────────────────
Минимизированные файлы обозначаются текстом (min) после названия языка.
Сгенерированные файлы обозначаются текстом (gen) после названия языка.
Вы можете контролировать средний размер строки в байтах, используя --min-gen-line-length например scc -z --min-gen-line-length 1 . Обратите внимание, что вам нужен -z поскольку изменение этого значения не подразумевает минимизированное обнаружение.
Вы можете полностью исключить минифицированные файлы из подсчета, используя флаг --no-min-gen . Файлы, соответствующие минифицированной проверке, будут исключены из вывода.
Переназначение
Некоторые файлы могут не иметь расширения. Они будут проверены на предмет наличия #! файл. Если да, то язык будет переназначен на правильный язык. В противном случае он не будет обрабатываться.
Однако может возникнуть ситуация, когда вы захотите переназначить такие файлы на основе строки внутри них. Для этого вы можете использовать --remap-unknown
scc --remap-unknown "-*- C++ -*-":"C Header"
Приведенное выше проверит любой файл без расширения в поисках строки -*- C++ -*- и, если она найдена, переназначит файл для подсчета с использованием правил заголовка C. При необходимости вы можете иметь несколько правил переназначения.
scc --remap-unknown "-*- C++ -*-":"C Header","other":"Java"
Существует также параметр --remap-all , который переназначит все файлы.
Обратите внимание, что во всех случаях, если правило переназначения не применяется, обычное #! правила будут применяться.
Выходные форматы
По умолчанию scc выводит на консоль. Однако при необходимости вы можете создавать выходные данные в других форматах.
Различные варианты: tabular, wide, json, csv, csv-stream, cloc-yaml, html, html-table, sql, sql-insert, openmetrics .
Обратите внимание, что вы можете записать вывод scc на диск, используя опцию -o, --output . Это позволяет вам указать файл для записи вывода. Например, scc -f html -o output.html запустит scc для текущего каталога и выведет результаты в формате html в файл output.html .
Вы также можете записывать в несколько выходных файлов или в несколько типов на стандартный вывод, если хотите использовать опцию --format-multi . Это наиболее полезно при работе в системах CI/CD, где вам нужны HTML-отчеты в качестве артефакта, а также отображение счетчиков в стандартном выводе.
scc --format-multi "tabular:stdout,html:output.html,csv:output.csv"
Вышеупомянутое будет работать с текущим каталогом, выводя на стандартный вывод вывод по умолчанию, а также записывая в выходные данные.html и вывод.csv в соответствующих форматах.
Табличный
Это формат вывода по умолчанию при запуске scc.
Широкий
Wide выдает некоторую дополнительную информацию, которая является метрикой сложности/линий. Это может быть полезно при попытке определить самый сложный файл внутри проекта на основе оценки сложности.
JSON
JSON создает выходные данные JSON. В основном предназначен для того, чтобы scc мог использоваться в других программах.
Обратите внимание, что этот формат даст вам размер в байтах каждого файла, прочитанного scc , что позволит вам получить разбивку по количеству обработанных байтов.
CSV-файл
CSV как вариант удобен для импорта в электронную таблицу для анализа.
Обратите внимание, что этот формат даст вам размер в байтах каждого файла, прочитанного scc , что позволит вам получить разбивку по количеству обработанных байтов. Также обратите внимание, что CSV учитывает --by-file и поэтому по умолчанию возвращает сводку.
CSV-поток
csv-stream — это опция, полезная для обработки очень больших репозиториев, где вы можете столкнуться с проблемами с памятью. Его выходной формат на 100% такой же, как CSV.
Обратите внимание, что вам не следует использовать это с опцией format-multi поскольку она всегда будет печатать в стандартный вывод и из-за того, как она работает, сведет на нет экономию памяти, которую она обычно получает. экономия, которую дает этот вариант. Обратите внимание, что с этой опцией сортировка не применяется.
cloc-yaml
Является заменой cloc с использованием опции вывода в формате yaml. Это довольно часто используется для перехода в другие системы сборки и при необходимости может помочь с заменой clock.
$ scc -f cloc-yml processor
# https://github.com/boyter/scc/
header:
url: https://github.com/boyter/scc/
version: 2.11.0
elapsed_seconds: 0.008
n_files: 21
n_lines: 6562
files_per_second: 2625
lines_per_second: 820250
Go:
name: Go
code: 5186
comment: 273
blank: 1103
nFiles: 21
SUM:
code: 5186
comment: 273
blank: 1103
nFiles: 21
$ cloc --yaml processor
21 text files.
21 unique files.
0 files ignored.
---
# http://cloc.sourceforge.net
header :
cloc_url : http://cloc.sourceforge.net
cloc_version : 1.60
elapsed_seconds : 0.196972846984863
n_files : 21
n_lines : 6562
files_per_second : 106.613679608407
lines_per_second : 33314.2364566841
Go:
nFiles: 21
blank: 1137
comment: 606
code: 4819
SUM:
blank: 1137
code: 4819
comment: 606
nFiles: 21
HTML и HTML-ТАБЛИЦА
Параметры вывода HTML создают минимальный отчет в формате HTML с использованием таблицы, которая представляет собой либо отдельный html , либо просто таблицу html-table , которую можно внедрить в ваши собственные HTML-страницы. Единственная разница между ними заключается в том, что опция html включает теги заголовка и тела HTML с минимальным стилем.
Разметка предназначена для применения ваших собственных стилей. Пример отчета доступен для просмотра.
Обратите внимание, что параметры HTML следуют за параметрами командной строки, поэтому вы можете использовать scc --by-file -f html для создания отчета по каждому файлу, а не только сводки.
Обратите внимание, что этот формат, если он имеет опцию --by-file , даст вам размер в байтах каждого файла, прочитанного scc что позволит вам получить разбивку по количеству обработанных байтов.
SQL и SQL-вставка
Формат вывода SQL «в основном» совместим с форматом вывода SQL Cloc https://github.com/AlDanial/cloc#sql-
Хотя все запросы в документации cloc должны работать должным образом, вы не сможете добавлять выходные данные scc и cloc в одну и ту же базу данных. Это связано с тем, что формат таблицы немного отличается для учета scc, включая счетчики сложности и байты.
Разница между sql и sql-insert заключается в том, что sql будет включать в себя создание таблиц, тогда как последний будет иметь только команды вставки.
Использование на 100% такое же, как и любая другая команда scc , но вывод sql всегда будет содержать сведения о каждом файле. Вы можете вычислить итоги самостоятельно, используя SQL, однако вычисления COCOMO будут отображаться на
