Sloc Cloc dan Kode (scc)
Alat yang mirip dengan cloc, sloccount dan tokei. Untuk menghitung baris kode, baris kosong, baris komentar, dan baris fisik kode sumber dalam banyak bahasa pemrograman.
Tujuannya adalah untuk menjadi penghitung kode tercepat, tetapi juga melakukan penghitungan COCOMO seperti sloccount, memperkirakan kompleksitas kode yang mirip dengan kalkulator kompleksitas siklomatik, dan menghasilkan baris kode unik atau metrik DRYness. Singkatnya, satu alat untuk mengatur semuanya.
Juga memiliki nama yang sangat pendek sehingga mudah untuk diketik scc .
Jika Anda tidak menyukai sloc cloc dan kode silakan gunakan nama Succinct Code Counter .
Berlisensi di bawah lisensi MIT.
Daftar isi
Mendukung
Menggunakan scc secara komersial? Jika Anda menginginkan dukungan prioritas untuk scc Anda dapat membeli https://boyter.gumroad.com/l/kgenuv senilai satu tahun yang memberi Anda hak untuk mendapatkan prioritas dukungan email langsung dari pengembang.
Memasang
Pergi Instal
Anda dapat menginstal scc dengan menggunakan go toolchain standar.
Untuk menginstal scc versi stabil terbaru:
go install github.com/boyter/scc/v3@latest
Untuk menginstal versi pengembangan:
go install github.com/boyter/scc/v3@master
Perhatikan bahwa scc memerlukan versi go >= 1.22.
Patah
Instalasi sekejap ada berkat Ricardo.
$ sudo snap install scc
Aplikasi yang diinstal NB Snap tidak dapat berjalan di luar /home https://askubuntu.com/questions/930437/permission-denied-error-when-running-apps-installed-as-snap-packages-ubuntu-17 sehingga Anda mungkin mengalami masalah jika Anda menggunakan snap dan mencoba menjalankan di luar direktori ini.
minuman rumahan
Atau jika Anda telah menginstal Homebrew
$ brew install scc
MacPort
Di macOS, Anda juga dapat menginstal melalui MacPorts
$ sudo port install scc
Sendok
Atau jika Anda menggunakan Scoop di Windows
$ scoop install scc
coklat
Atau jika Anda menggunakan Chocolatey di Windows
$ choco install scc
Dapatkan Win
Atau jika Anda menggunakan WinGet di Windows
winget install --id benboyter.scc --source winget
FreeBSD
Di FreeBSD, scc tersedia sebagai sebuah paket
$ pkg install scc
Atau, jika Anda lebih suka membangun dari sumber, Anda bisa menggunakan pohon port
$ cd /usr/ports/devel/scc && make install clean
Jalankan di Docker
Buka direktori tempat Anda ingin menjalankan scc.
Jalankan perintah di bawah ini untuk menjalankan rilis terbaru scc di direktori kerja Anda saat ini:
docker run --rm -it -v "$PWD:/pwd" ghcr.io/lhoupert/scc:master scc /pwd
petunjuk
Biner untuk Windows, GNU/Linux dan macOS untuk mesin i386 dan x86_64 tersedia dari halaman rilis.
GitLab
https://about.gitlab.com/blog/2023/02/15/code-counting-in-gitlab/
Lainnya
Jika Anda ingin membantu menambahkan scc ke apt/chocolatey/etc... silakan kirimkan PR atau setidaknya ajukan masalah dengan instruksi.
Latar belakang
Baca semua tentang bagaimana hal ini bisa terjadi bersamaan dengan tolok ukur kinerja,
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-kinerja/
https://boyter.org/posts/sloc-cloc-code-kinerja-update/
Beberapa ulasan tentang 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
Ceramah yang diberikan pada GopherCon AU pertama tentang scc (tekan S untuk melihat catatan pembicara)
Untuk kinerja lihat bagian Kinerja
Proyek serupa lainnya,
SLOCChitung penghitung sloc asli
cloc, terinspirasi oleh SLOCCount; diimplementasikan di Perl untuk portabilitas
gocloc penghitung sloc di Go terinspirasi oleh tokei
implementasi loc karat mirip dengan tokei tetapi seringkali lebih cepat
Implementasi loccount Go ditulis dan dikelola oleh ESR
penghitung sloc ATS poliglot
tokei cepat, akurat dan ditulis dengan karat
penghitung kode skrip kopi sloc
stto penghitung kode Go baru dengan fokus pada kinerja
Bacaan menarik tentang proyek penghitungan kode lainnya tokei, loc, polyglot, dan 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
Bacaan lebih lanjut tentang kinerja pemrosesan file pada disk
Menggunakan scc untuk memproses 40 TB file dari GitHub/Bitbucket/GitLab
Melempar
Mengapa menggunakan scc ?
Ini sangat cepat dan semakin cepat semakin banyak CPU yang Anda gunakan
Tepat
Bekerja dengan sangat baik di berbagai platform tanpa perlambatan (Windows, Linux, macOS)
Dukungan bahasa yang besar
Dapat mengabaikan file duplikat
Memiliki estimasi kompleksitas
Anda perlu membedakan antara Coq dan Verilog di direktori yang sama
dukungan keluaran cloc yaml sehingga berpotensi menjadi pengganti bagi beberapa pengguna
Dapat mengidentifikasi atau mengabaikan file yang diperkecil
Mampu mengidentifikasi banyak #! file LANJUTAN! #115
Dapat mengabaikan file besar berdasarkan baris atau byte
Dapat menghitung ULOC atau baris kode unik berdasarkan file, bahasa, atau proyek
Mendukung berbagai format keluaran untuk integrasi, CSV, SQL, JSON, HTML, dan lainnya
Mengapa tidak menggunakan scc ?
Perbedaan
Ada beberapa perbedaan penting antara scc dan alat lain yang ada di luar sana. Berikut beberapa hal penting untuk Anda pertimbangkan.
Baris kosong di dalam komentar dihitung sebagai komentar. Meskipun baris tersebut secara teknis kosong, keputusan dibuat bahwa sekali dalam sebuah komentar, semua yang ada di sana harus dianggap sebagai komentar hingga komentar tersebut berakhir. Seperti berikut ini,
/* blank lines follow
*/
Akan dihitung sebagai 4 baris komentar. Hal ini terlihat ketika membandingkan keluaran scc dengan alat lain di repositori besar.
scc dapat menghitung string kata demi kata dengan benar. Misalnya di C# berikut ini,
private const string BasePath = @"a:";
// The below is returned to the user as a version
private const string Version = "1.0.0";
Karena awalan @ string ini berakhir di akhir " dengan mengabaikan karakter escape dan dengan demikian harus dihitung sebagai 2 baris kode dan 1 komentar. Beberapa alat tidak dapat menangani hal ini dan malah menghitung hingga "1.0.0" sebagai string yang dapat menyebabkan komentar tengah dihitung sebagai kode, bukan komentar.
scc juga akan memberi tahu Anda jumlah byte yang telah diproses (untuk sebagian besar format keluaran) sehingga Anda dapat memperkirakan biaya menjalankan beberapa alat analisis statis.
Penggunaan
Penggunaan baris perintah scc dirancang sesederhana mungkin. Detail selengkapnya dapat ditemukan di scc --help atau scc -h . Perhatikan bahwa yang di bawah ini mencerminkan status master, bukan rilis, karena fitur-fitur yang tercantum di bawah ini mungkin hilang dari instalasi Anda.
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)
Outputnya akan terlihat seperti di bawah ini untuk proyek 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)
───────────────────────────────────────────────────────────────────────────────
Perhatikan bahwa Anda tidak perlu menentukan direktori yang ingin Anda jalankan. Menjalankan scc akan menganggap Anda ingin menjalankannya pada direktori saat ini.
Anda juga dapat menjalankan beberapa file atau direktori scc directory1 directory2 file1 file2 dengan hasil yang dikumpulkan dalam output.
Karena scc menulis ke keluaran standar, ada banyak cara untuk membagikan hasilnya dengan mudah. Misalnya, menggunakan netcat dan salah satu dari banyak pastebin memberikan URL publik:
$ scc | nc paste.c-net.org 9999
https://paste.c-net.org/Example
Abaikan File
scc sebagian besar mendukung file .ignore di dalam direktori yang dipindai. Ini mirip dengan cara kerja ripgrep, ag, dan tokei. File .ignore 100% sama dengan file .gitignore dengan sintaks yang sama, dan dengan demikian scc akan mengabaikan file dan direktori yang terdaftar di dalamnya. Anda dapat menambahkan file .ignore untuk mengabaikan hal-hal seperti ketergantungan vendor yang diperiksa pada file dan semacamnya. Idenya adalah memungkinkan Anda untuk menambahkan file atau folder ke git dan mengabaikannya.
Ini juga mendukung file abaikannya sendiri .sccignore jika Anda ingin scc mengabaikan sesuatu sementara ripgrep, ag, tokei, dan lainnya mendukungnya.
Kasus Penggunaan yang Menarik
Digunakan di dalam Intel Nemu Hypervisor untuk melacak perubahan kode antar revisi https://github.com/intel/nemu/blob/topic/virt-x86/tools/cloc-change.sh#L9 Tampaknya juga digunakan di dalam keduanya http:/ /codescoop.com/ https://pinpoint.com/ https://github.com/chaoss/grimoirelab-graal
Ini juga digunakan untuk menghitung kode dan menebak jenis bahasa di https://searchcode.com/ yang menjadikannya salah satu penghitung kode yang paling sering dijalankan di dunia.
Anda juga dapat menghubungkan scc ke saluran gitlab Anda https://gitlab.com/guided-explorations/ci-cd-plugin-extensions/ci-cd-plugin-extension-scc
Juga digunakan oleh CodeQL #317 dan Scaleway https://twitter.com/Scaleway/status/1488087029476995074?s=20&t=N2-z6O-ISDdDzULg4o4uVQ
Fitur
scc menggunakan mesin status kecil untuk menentukan status kode saat mencapai baris baru n . Dengan demikian ia sadar dan mampu menghitung
Komentar Satu Baris
Komentar Multi Baris
string
String Multi Baris
Garis kosong
Oleh karena itu, ia dapat menentukan secara akurat apakah suatu komentar ada dalam sebuah string atau benar-benar sebuah komentar.
Ia juga mencoba menghitung kompleksitas kode. Hal ini dilakukan dengan memeriksa operasi percabangan dalam kode. Misalnya, setiap kalimat berikut for if switch while else || && != == jika ditemui di Java akan menambah kompleksitas file sebanyak satu.
Perkiraan Kompleksitas
Mari luangkan waktu sejenak untuk membahas perkiraan kompleksitas itu sendiri.
Perkiraan kompleksitas sebenarnya hanyalah angka yang hanya sebanding dengan file dalam bahasa yang sama. Ini tidak boleh digunakan untuk membandingkan bahasa secara langsung tanpa memberi bobot pada bahasa tersebut. Alasannya adalah karena ini dihitung dengan mencari pernyataan cabang dan loop dalam kode dan menambah penghitung untuk file tersebut.
Karena beberapa bahasa tidak memiliki loop dan malah menggunakan rekursi, maka bahasa tersebut memiliki jumlah kompleksitas yang lebih rendah. Apakah ini berarti mereka tidak terlalu rumit? Mungkin tidak, tetapi alat tersebut tidak dapat melihatnya karena tidak membuat AST kode karena hanya memindai kode tersebut.
Secara umum kompleksitas yang ada adalah untuk membantu memperkirakan antar proyek yang ditulis dalam bahasa yang sama, atau untuk menemukan file paling kompleks dalam suatu proyek scc --by-file -s complexity yang dapat berguna ketika Anda memperkirakan seberapa sulitnya sesuatu untuk dilakukan. memelihara, atau ketika mencari file-file yang mungkin harus difaktorkan ulang.
Adapun cara kerjanya.
Itu definisi saya sendiri, tetapi mencoba menjadi perkiraan kompleksitas siklomatik https://en.wikipedia.org/wiki/Cyclomatic_complexity meskipun hanya dilakukan pada level file.
Alasan mengapa ini merupakan perkiraan adalah karena ini dihitung hampir gratis dari sudut pandang CPU (karena ini merupakan pencarian yang murah saat menghitung), sedangkan penghitungan kompleksitas siklomatik yang sebenarnya perlu menguraikan kodenya. Ini memberikan tebakan yang masuk akal dalam praktiknya meskipun gagal mengidentifikasi metode rekursif. Tujuannya bukanlah untuk memastikannya secara tepat.
Singkatnya ketika scc melihat melalui apa yang telah diidentifikasi sebagai kode, jika ia memperhatikan kondisi cabang yang biasanya, ia akan menambah penghitung.
Kondisi yang dicari dikompilasi ke dalam kode dan Anda bisa mendapatkan idenya dengan melihat JSON di dalam repositori. Lihat https://github.com/boyter/scc/blob/master/linguals.json#L3869 untuk contoh tampilan file Java.
Peningkatan terjadi untuk setiap kondisi pencocokan dan menghasilkan angka yang Anda lihat.
Baris Kode Unik (ULOC)
ULOC adalah singkatan dari Unique Lines of Code dan mewakili baris unik di seluruh bahasa, file, dan proyek itu sendiri. Ide ini diambil dari https://cmcenroe.me/2018/12/14/uloc.html dimana perhitungannya disajikan menggunakan alat standar Unix sort -u *.h *.c | wc -l . Metrik ini ada untuk membantu memperkirakan kompleksitas dalam proyek. Mengutip sumbernya
Menurut pendapat saya, jumlah yang dihasilkan seharusnya merupakan perkiraan yang lebih baik mengenai kompleksitas suatu proyek. Dibandingkan dengan SLOC, tidak hanya baris kosong yang didiskon, namun juga baris kurung kurawal dan kode berulang lainnya seperti penyertaan umum. Di sisi lain, ULOC menghitung komentar, yang memerlukan pemeliharaan sama banyaknya dengan kode di sekitarnya, sekaligus menghindari penggelembungan hasil dengan header lisensi yang muncul di setiap file, misalnya.
Anda dapat memperoleh ULOC dengan memberikan argumen -u atau --uloc ke scc .
Ini memiliki metrik yang sesuai DRYness % yang merupakan persentase ULOC terhadap CLOC atau DRYness = ULOC / SLOC . Semakin tinggi angkanya, semakin KERING (jangan ulangi lagi) proyek tersebut dapat dipertimbangkan. Secara umum, nilai yang lebih tinggi di sini lebih baik karena menunjukkan lebih sedikit kode duplikat. Metrik DRYness diambil dari komentar minimax https://lobste.rs/s/has9r7/uloc_unique_lines_code
Untuk mendapatkan metrik DRYness Anda dapat menggunakan argumen -a atau --dryness ke scc , yang secara implisit akan menyetel --uloc .
Perhatikan bahwa ada penalti kinerja saat menghitung metrik ULOC yang dapat menggandakan waktu proses.
Menjalankan perhitungan uloc dan DRYness terhadap kode C, tiruan dari redis menghasilkan output sebagai berikut.
$ 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)
───────────────────────────────────────────────────────────────────────────────
Bacaan lebih lanjut tentang perhitungan ULOC dapat ditemukan di https://boyter.org/posts/sloc-cloc-code-new-metic-uloc/
COCOMO
Statistik COCOMO yang ditampilkan di bagian bawah setiap baris perintah yang dijalankan dapat dikonfigurasi sesuai kebutuhan.
Estimated Cost to Develop (organic) $664,081
Estimated Schedule Effort (organic) 11.772217 months
Estimated People Required (organic) 5.011633
Untuk mengubah parameter COCOMO, Anda dapat menggunakan salah satu model COCOMO default.
scc --cocomo-project-type organic
scc --cocomo-project-type semi-detached
scc --cocomo-project-type embedded
Anda juga dapat menyediakan parameter Anda sendiri jika Anda familiar dengan COCOMO sebagai berikut,
scc --cocomo-project-type "custom,1,1,1,1"
Lihat di bawah untuk detail tentang cara pemilihan model, dan parameter yang digunakan.
Organik – Sebuah proyek perangkat lunak dikatakan bertipe organik jika ukuran tim yang diperlukan cukup kecil, masalahnya dipahami dengan baik dan telah dipecahkan di masa lalu dan juga anggota tim memiliki sedikit pengalaman mengenai masalah tersebut.
scc --cocomo-project-type "organic,2.4,1.05,2.5,0.38"
Semi-terpisah – Sebuah proyek perangkat lunak dikatakan bertipe Semi-terpisah jika karakteristik penting seperti ukuran tim, pengalaman, pengetahuan tentang berbagai lingkungan pemrograman terletak di antara organik dan Tertanam. Proyek-proyek yang diklasifikasikan sebagai Semi-Terpisah relatif kurang familiar dan sulit untuk dikembangkan dibandingkan dengan proyek-proyek organik dan memerlukan lebih banyak pengalaman serta bimbingan dan kreativitas yang lebih baik. Misalnya: Kompiler atau Sistem Tertanam yang berbeda dapat dianggap bertipe Semi-Terpisah.
scc --cocomo-project-type "semi-detached,3.0,1.12,2.5,0.35"
Tertanam – Proyek perangkat lunak yang memerlukan tingkat kompleksitas, kreativitas, dan pengalaman tertinggi termasuk dalam kategori ini. Perangkat lunak tersebut memerlukan ukuran tim yang lebih besar dibandingkan dua model lainnya dan juga pengembang harus cukup berpengalaman dan kreatif untuk mengembangkan model kompleks tersebut.
scc --cocomo-project-type "embedded,3.6,1.20,2.5,0.32"
Deteksi File Besar
Anda dapat meminta scc mengecualikan file besar dari output.
Opsi untuk melakukannya adalah --no-large yang secara default akan mengecualikan file lebih dari 1.000.000 byte atau 40.000 baris.
Anda dapat mengontrol ukuran nilai mana pun menggunakan --large-byte-count atau --large-line-count .
Misalnya untuk mengecualikan file lebih dari 1.000 baris dan 50kb Anda dapat menggunakan yang berikut ini,
scc --no-large --large-byte-count 50000 --large-line-count 1000
Deteksi File yang Diperkecil/Dihasilkan
Anda dapat meminta scc mengidentifikasi dan secara opsional menghapus file yang diidentifikasi sebagai diperkecil atau dihasilkan dari output.
Anda dapat melakukannya dengan mengaktifkan flag -z seperti scc -z yang akan mengidentifikasi file apa pun dengan ukuran byte baris rata-rata >= 255 (secara default) sebagai file yang diperkecil.
File yang diperkecil tampak seperti itu di output.
$ 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)
───────────────────────────────────────────────────────────────────────────────
File yang diperkecil ditandai dengan teks (min) setelah nama bahasa.
File yang dihasilkan ditandai dengan teks (gen) setelah nama bahasa.
Anda dapat mengontrol ukuran byte baris rata-rata menggunakan --min-gen-line-length seperti scc -z --min-gen-line-length 1 . Harap diperhatikan bahwa Anda memerlukan -z karena mengubah nilai ini tidak berarti deteksi diperkecil.
Anda dapat mengecualikan file yang diperkecil dari penghitungan total menggunakan flag --no-min-gen . File yang cocok dengan pemeriksaan yang diperkecil akan dikeluarkan dari output.
Memetakan ulang
Beberapa file mungkin tidak memiliki ekstensi. Mereka akan diperiksa untuk melihat apakah mereka #! mengajukan. Jika ya, maka bahasa tersebut akan dipetakan ulang ke bahasa yang benar. Jika tidak, maka tidak akan diproses.
Namun, Anda mungkin mengalami situasi di mana Anda ingin memetakan ulang file tersebut berdasarkan string di dalamnya. Untuk melakukannya, Anda dapat menggunakan --remap-unknown
scc --remap-unknown "-*- C++ -*-":"C Header"
Di atas akan memeriksa file apa pun tanpa ekstensi mencari string -*- C++ -*- dan jika ditemukan memetakan ulang file untuk dihitung menggunakan aturan C Header. Anda dapat memiliki beberapa aturan pemetaan ulang jika diperlukan,
scc --remap-unknown "-*- C++ -*-":"C Header","other":"Java"
Ada juga parameter --remap-all yang akan memetakan ulang semua file.
Perhatikan bahwa dalam semua kasus jika aturan remap tidak berlaku #! aturan akan berlaku.
Format Keluaran
Secara default, scc akan ditampilkan ke konsol. Namun, Anda dapat menghasilkan keluaran dalam format lain jika diperlukan.
Opsi yang berbeda adalah tabular, wide, json, csv, csv-stream, cloc-yaml, html, html-table, sql, sql-insert, openmetrics .
Perhatikan bahwa Anda dapat menulis keluaran scc ke disk menggunakan opsi -o, --output . Ini memungkinkan Anda menentukan file untuk menulis output Anda. Misalnya scc -f html -o output.html akan menjalankan scc pada direktori saat ini, dan menampilkan hasilnya dalam html ke file output.html .
Anda juga dapat menulis ke beberapa file keluaran, atau beberapa tipe ke stdout jika Anda ingin menggunakan opsi --format-multi . Ini paling berguna ketika bekerja dalam sistem CI/CD di mana Anda ingin laporan HTML sebagai artefak sekaligus menampilkan hitungan di stdout.
scc --format-multi "tabular:stdout,html:output.html,csv:output.csv"
Hal di atas akan dijalankan pada direktori saat ini, menghasilkan keluaran standar sebagai keluaran default, serta menulis ke keluaran.html dan keluaran.csv dengan format yang sesuai.
Datar
Ini adalah format keluaran default ketika scc dijalankan.
Lebar
Wide menghasilkan beberapa informasi tambahan yaitu metrik kompleksitas/garis. Ini dapat berguna ketika mencoba mengidentifikasi file paling kompleks di dalam suatu proyek berdasarkan perkiraan kompleksitas.
JSON
JSON menghasilkan keluaran JSON. Sebagian besar dirancang untuk memungkinkan scc dimasukkan ke dalam program lain.
Perhatikan bahwa format ini akan memberi Anda ukuran byte dari setiap file yang dibaca scc sehingga memungkinkan Anda mendapatkan rincian jumlah byte yang diproses.
CSV
CSV sebagai opsi bagus untuk diimpor ke spreadsheet untuk dianalisis.
Perhatikan bahwa format ini akan memberi Anda ukuran byte dari setiap file yang dibaca scc sehingga memungkinkan Anda mendapatkan rincian jumlah byte yang diproses. Perhatikan juga bahwa CSV menghormati --by-file dan dengan demikian akan mengembalikan ringkasan secara default.
Aliran CSV
csv-stream adalah opsi yang berguna untuk memproses repositori yang sangat besar di mana Anda mungkin mengalami masalah memori. Format keluarannya 100% sama dengan CSV.
Perhatikan bahwa Anda tidak boleh menggunakan ini dengan opsi format-multi karena ini akan selalu mencetak ke keluaran standar, dan karena cara kerjanya akan meniadakan penyimpanan memori yang biasanya diperolehnya. penghematan yang diberikan opsi ini. Perhatikan bahwa tidak ada pengurutan yang diterapkan dengan opsi ini.
jam-yaml
Merupakan pengganti cloc menggunakan opsi keluaran yamlnya. Ini cukup sering digunakan untuk meneruskan ke sistem build lain dan dapat membantu mengganti cloc jika diperlukan.
$ 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 dan HTML-TABEL
Opsi keluaran HTML menghasilkan laporan html minimal menggunakan tabel yang merupakan html mandiri atau hanya sebagai tabel html-table yang dapat dimasukkan ke halaman HTML Anda sendiri. Satu-satunya perbedaan antara keduanya adalah opsi html menyertakan tag kepala dan badan html dengan gaya minimal.
Markup dirancang untuk memungkinkan gaya kustom Anda diterapkan. Contoh laporan ada di sini untuk dilihat.
Perhatikan bahwa opsi HTML mengikuti opsi baris perintah, sehingga Anda dapat menggunakan scc --by-file -f html untuk menghasilkan laporan dengan setiap file dan bukan hanya ringkasannya.
Perhatikan bahwa format ini jika memiliki opsi --by-file akan memberi Anda ukuran byte dari setiap file yang dibaca scc sehingga Anda dapat memperoleh perincian jumlah byte yang diproses.
SQL dan Sisipkan SQL
Format keluaran SQL "kebanyakan" kompatibel dengan format keluaran SQL cloc https://github.com/AlDanial/cloc#sql-
Meskipun semua kueri pada dokumentasi cloc akan berfungsi seperti yang diharapkan, Anda tidak akan dapat menambahkan keluaran dari scc dan cloc ke dalam database yang sama. Hal ini karena format tabel sedikit berbeda untuk memperhitungkan scc termasuk jumlah kompleksitas dan byte.
Perbedaan antara sql dan sql-insert adalah sql akan menyertakan pembuatan tabel sedangkan sql hanya memiliki perintah penyisipan.
Penggunaannya 100% sama dengan perintah scc lainnya tetapi keluaran sql akan selalu berisi detail per file. Anda dapat menghitung sendiri totalnya menggunakan SQL, namun penghitungan COCOMO akan muncul berlawanan dengan
