Обзор
Cloc считает пустые строки, строки комментариев и физические строки исходного кода во многих языках программирования. Учитывая две версии кодовой базы, cloc может вычислить разницу в пустой строке, комментарии и строке исходного кода. Он написан полностью на Perl без внешних зависимостей от стандартного дистрибутива Perl версии 5.6 и выше (код от некоторых внешних модулей встроен в cloc) и это довольно мобильно. Cloc может запускаться на многих версиях Linux, FreeBSD, NetBSD, OpenBSD, Mac OS X, AIX, HP-UX, Solaris, IRIX, z/OS и Windows. (Для запуска Perl версии cloc на Windows, необходим ActiveState Perl 5.6.1 или выше, Strawberry Perl, Cygwin или MobaXTerm с установленным Perl-плагином. В качестве альтернативы можно использовать Windows бинары из cloc cгенерированные PAR::Packer для запуска на компьютерах Windows, которые не имеют ни Perl, ни Cygwin.)
Cloc содержит код от SLOCCount Дэвида Уилера, Damian Conway и Perl модуль Абигейла Regexp::Common, Perl модуль Шона М. Берка Win32::Autoglob, и Perl модуль Тай Маккуина Algorithm::Diff. Масштабируемые коэффициенты языка были получены от Mayes Consulting, LLC, веб-сайт http://softwareestimator.com/IndustryData2.htm.
Установка с помощью менеджера пакетов
В зависимости от вашей операционной системы, для вас может работать один из этих способов установки:
npm install -g cloc # https://www.npmjs.com/package/cloc sudo apt-get install cloc # Debian, Ubuntu sudo yum install cloc # Fedora sudo pacman -S cloc # Arch
Скачать стабильный релиз
�?сходный код, замечания по выпуску, Windows исполняемый файл, и Unix пакет для текущего стабильного релиза можно найти на http://sourceforge.net/projects/cloc/files/cloc/v1.64/.
Лицензия
Cloc находится под лицензией GNU General Public License v2, за исключением частей, которые были скопированы из других источников. Код скопированный из Perl модулей Regexp::Common, Win32::Autoglob, и Algorithm::Diff это предмет Artistic License.
Зачем использовать Cloc?
Cloc имеет много особенностей, которые делают его простым в использовании, законченным, расширяемым и переносимым:
1. Существует в виде единого автономного файла, который требует минимальных усилий для установки --- просто скачать файл и запустить его.
2. Можно читать языковые комментарий из файла и, таким образом, потенциально работать с компьютерными языками, которые еще не существуют.
3. Позволяет результатам нескольких запусков быть подсчитанными вместе языком и проектом.
4. Может производить результаты в различных форматах: текст, SQL, XML, YAML, с разделенными запятой значениями.
5. Может считать код в сжатых архивах (tar balls, Zip файлах, Java .ear файлах).
6. �?меет многочисленные варианты устранения неполадок.
7. Управляет именами файлов и каталогов с пробелами и другими необычными персонажами.
8. Не имеет зависимостей за пределами стандартного дистрибутива Perl.
9. Работает на Linux, FreeBSD, NetBSD, OpenBSD, Mac OS X, AIX, HP-UX, Solaris, IRIX, и системах z/ OS, которые имеют Perl 5.6 или выше. �?сходная версия работает на Windows, либо с любым ActiveState Perl, Strawberry Perl, Cygwin или MobaXTerm + Perl плагин. Кроме Windows, может работать на Windows binary, который не имеет зависимостей.
Другие Счетчики
Если Cloc не удовлетворяет вашим потребностям, то здесь есть для рассмотрения и другие, свободно доступные счетчики:
• Sonar
• Ohcount
• sclc
• USC's CODECOUNT
• loc
Другие ссылки:
• QSM каталог инструментов считающих код
• Запись в Википедии для счетчиков линий кода
Regexp::Common, Digest::MD5, Win32::Autoglob, Algorithm::Diff
Хотя Cloc не нужно Perl модулей вне те, что в стандартной поставке, Cloc действительно полагается на несколько внешних модулей. Код от трех этих внешних модулей - Regexp :: Common, Win32::Autoglob, и Algorithm::Diff - встраивается в Cloc. Четвертый модуль, Digest::MD5, используется только если это возможно. Если Cloc находит Regexp::Common или установлена Algorithm::Diff локально он будет использовать те установки. Если это не так, Cloc установит части Regexp::Common и / или Algorithm::Diff он должен временных каталогов, создаваемых в начале Cloc перспективе, то удаляется, когда пробег будет завершена. Необходимый код из RegExp::Common v2.120 и Algorithm::Diff v1.1902 встроены в исходный код Cloc (см подпрограмм Install_Regexp_Common() и Install_Algorithm_Diff()). Только три линии необходимо от Win32::Autoglob, и они включены непосредственно в Cloc.
Кроме того, Cloc будет использовать Digest::MD5 для проверки уникальности среди входных файлов, если установлен Digest::MD5 локально. Если Digest::MD5 не найден проверка уникальности файл пропускается.
Двоичный Windows, построен на компьютере и регулярных Regexp::Common и Digest::MD5 установлены локально.
Построение Windows исполняемой версии
Скачать Windows по умолчанию, Cloc-1.64.exe, был построен с PAR::Packer на Windows 7 компьютере с Strawberry Perl. Windows исполняемые Cloc версии 1.60 и ранее были построены с perl2exe на 32-битной Windows XP компьютер. Небольшой модификации было сделано в исходном коде Cloc перед его передачей perl2exe; линии 87 и 88 были раскомментированы:
85 # Uncomment next two lines when building Windows executable with perl2exe 86 # or if running on a system that already has Regexp::Common. 87 #use Regexp::Common; 88 #$HAVE_Rexexp_Common = 1;
Почему версия для Windows настолько большая?
Windows исполняемые Cloc версии 1.60 и выше, создан с perl2exe как отмечалось выше, около 1,6 Мб, в то время как более новые версии, созданные с PAR::Packer, 11 МБ. Почему новые исполняемые настолько больше? Моя теория состоит в том, что perl2exe использует умнее Обрезка деревьев логику, чем PAR::Packer, но это чистая спекуляция.
Создайте свою собственную исполняемую версию
Если у вас есть доступ к perl2exe, вы можете использовать его для создания жесткой исполняемый Windows. См линии 84-87 в исходном коде Cloc для незначительного изменения кода, что необходимо при использовании perl2exe.
В противном случае, чтобы построить исполняемый файл Windows, с pp от PAR::Packer сначала установить Windows, основанный распределение Perl (например Perl или Strawberry ActivePerl) после их поручению. Далее, откройте командную строку, иначе в окне DOS и установить модуль PAR::Packer. Наконец, вызовите команду вновь установленный pp с Cloc код соусе создать .exe -файл:
C:> perl -MCPAN -e shell cpan> install PAR::Packer cpan> exit C:> pp cloc-1.64.pl
Вариация на выше, если вы установили портативную версию Strawberry Perl, вам нужно будет запустить portableshell.bat первым правильно настроить среду. Strawberry Perl получены исполняемый на SourceForge загрузить район был создан с переносной версии на компьютере Windows 7.
Основное применение
Cloc это программа командной строки, которая принимает файл, каталог и/или имена архивных как входы. Вот пример запуска Cloc против распространения Perl v5.10.0 источника:
prompt> cloc perl-5.10.0.tar.gz
4076 text files.
3883 unique files.
1521 files ignored.
http://https://github.com v 1.50 T=12.0 s (209.2 files/s, 70472.1 lines/s)
-------------------------------------------------------------------------------
Language files blank comment code
-------------------------------------------------------------------------------
Perl 2052 110356 130018 292281
C 135 18718 22862 140483
C/C++ Header 147 7650 12093 44042
Bourne Shell 116 3402 5789 36882
Lisp 1 684 2242 7515
make 7 498 473 2044
C++ 10 312 277 2000
XML 26 231 0 1972
yacc 2 128 97 1549
YAML 2 2 0 489
DOS Batch 11 85 50 322
HTML 1 19 2 98
-------------------------------------------------------------------------------
SUM: 2510 142085 173903 529677
-------------------------------------------------------------------------------
Чтобы запустить Cloc на компьютерах Windows, нужно сначала открыть команду (ака DOS) окно и вызвать cloc.exe из командной строки нет.
Опции
prompt> cloc
Usage: cloc [options] <file(s)/dir(s)> | <set 1> <set 2> | <report files>
Count, or compute differences of, physical lines of source code in the
given files (may be archives such as compressed tarballs or zip files)
and/or recursively below the given directories.
Input Options
--extract-with=<cmd> This option is only needed if cloc is unable
to figure out how to extract the contents of
the input file(s) by itself.
Use <cmd> to extract binary archive files (e.g.:
.tar.gz, .zip, .Z). Use the literal '>FILE<' as
a stand-in for the actual file(s) to be
extracted. For example, to count lines of code
in the input files
gcc-4.2.tar.gz perl-5.8.8.tar.gz
on Unix use
--extract-with='gzip -dc >FILE< | tar xf -'
or, if you have GNU tar,
--extract-with='tar zxf >FILE<'
and on Windows use, for example:
--extract-with="\"c:\Program Files\WinZip\WinZip32.exe\" -e -o >FILE< ."
(if WinZip is installed there).
--list-file=<file> Take the list of file and/or directory names to
process from <file>, which has one file/directory
name per line. Only exact matches are counted;
relative path names will be resolved starting from
the directory where cloc is invoked.
See also --exclude-list-file.
--unicode Check binary files to see if they contain Unicode
expanded ASCII text. This causes performance to
drop noticably.
Processing Options
--autoconf Count .in files (as processed by GNU autoconf) of
recognized languages.
--by-file Report results for every source file encountered.
--by-file-by-lang Report results for every source file encountered
in addition to reporting by language.
--count-and-diff <set1> <set2>
First perform direct code counts of source file(s)
of <set1> and <set2> separately, then perform a diff
of these. Inputs may be pairs of files, directories,
or archives. See also --diff, --diff-alignment,
--diff-timeout, --ignore-case, --ignore-whitespace.
--diff <set1> <set2> Compute differences in code and comments between
source file(s) of <set1> and <set2>. The inputs
may be pairs of files, directories, or archives.
Use --diff-alignment to generate a list showing
which file pairs where compared. See also
--count-and-diff, --diff-alignment, --diff-timeout,
--ignore-case, --ignore-whitespace.
--diff-timeout <N> Ignore files which take more than <N> seconds
to process. Default is 10 seconds.
(Large files with many repeated lines can cause
Algorithm::Diff::sdiff() to take hours.)
--follow-links [Unix only] Follow symbolic links to directories
(sym links to files are always followed).
--force-lang=<lang>[,<ext>]
Process all files that have a <ext> extension
with the counter for language <lang>. For
example, to count all .f files with the
Fortran 90 counter (which expects files to
end with .f90) instead of the default Fortran 77
counter, use
--force-lang="Fortran 90",f
If <ext> is omitted, every file will be counted
with the <lang> counter. This option can be
specified multiple times (but that is only
useful when <ext> is given each time).
See also --script-lang, --lang-no-ext.
--force-lang-def=<file> Load language processing filters from <file>,
then use these filters instead of the built-in
filters. Note: languages which map to the same
file extension (for example:
MATLAB/Objective C/MUMPS/Mercury; Pascal/PHP;
Lisp/OpenCL; Lisp/Julia; Perl/Prolog) will be
ignored as these require additional processing
that is not expressed in language definition
files. Use --read-lang-def to define new
language filters without replacing built-in
filters (see also --write-lang-def).
--ignore-whitespace Ignore horizontal white space when comparing files
with --diff. See also --ignore-case.
--ignore-case Ignore changes in case; consider upper- and lower-
case letters equivalent when comparing files with
--diff. See also --ignore-whitespace.
--lang-no-ext=<lang> Count files without extensions using the <lang>
counter. This option overrides internal logic
for files without extensions (where such files
are checked against known scripting languages
by examining the first line for #!). See also
--force-lang, --script-lang.
--max-file-size=<MB> Skip files larger than <MB> megabytes when
traversing directories. By default, <MB>=100.
cloc's memory requirement is roughly twenty times
larger than the largest file so running with
files larger than 100 MB on a computer with less
than 2 GB of memory will cause problems.
Note: this check does not apply to files
explicitly passed as command line arguments.
--read-binary-files Process binary files in addition to text files.
This is usually a bad idea and should only be
attempted with text files that have embedded
binary data.
--read-lang-def=<file> Load new language processing filters from <file>
and merge them with those already known to cloc.
If <file> defines a language cloc already knows
about, cloc's definition will take precedence.
Use --force-lang-def to over-ride cloc's
definitions (see also --write-lang-def ).
--script-lang=<lang>,<s> Process all files that invoke <s> as a #!
scripting language with the counter for language
<lang>. For example, files that begin with
#!/usr/local/bin/perl5.8.8
will be counted with the Perl counter by using
--script-lang=Perl,perl5.8.8
The language name is case insensitive but the
name of the script language executable, <s>,
must have the right case. This option can be
specified multiple times. See also --force-lang,
--lang-no-ext.
--sdir=<dir> Use <dir> as the scratch directory instead of
letting File::Temp chose the location. Files
written to this location are not removed at
the end of the run (as they are with File::Temp).
--skip-uniqueness Skip the file uniqueness check. This will give
a performance boost at the expense of counting
files with identical contents multiple times
(if such duplicates exist).
--stdin-name=<file> Give a file name to use to determine the language
for standard input.
--strip-comments=<ext> For each file processed, write to the current
directory a version of the file which has blank
lines and comments removed. The name of each
stripped file is the original file name with
.<ext> appended to it. It is written to the
current directory unless --original-dir is on.
--original-dir [Only effective in combination with
--strip-comments] Write the stripped files
to the same directory as the original files.
--sum-reports Input arguments are report files previously
created with the --report-file option. Makes
a cumulative set of results containing the
sum of data from the individual report files.
--unix Override the operating system autodetection
logic and run in UNIX mode. See also
--windows, --show-os.
--windows Override the operating system autodetection
logic and run in Microsoft Windows mode.
See also --unix, --show-os.
Filter Options
--exclude-dir=<D1>[,D2,] Exclude the given comma separated directories
D1, D2, D3, et cetera, from being scanned. For
example --exclude-dir=.cache,test will skip
all files that have /.cache/ or /test/ as part
of their path.
Directories named .bzr, .cvs, .hg, .git, and
.svn are always excluded.
--exclude-ext=<ext1>[,<ext2>[...]]
Do not count files having the given file name
extensions.
--exclude-lang=<L1>[,L2,] Exclude the given comma separated languages
L1, L2, L3, et cetera, from being counted.
--exclude-list-file=<file> Ignore files and/or directories whose names
appear in <file>. <file> should have one file
name per line. Only exact matches are ignored;
relative path names will be resolved starting from
the directory where cloc is invoked.
See also --list-file.
--include-lang=<L1>[,L2,] Count only the given comma separated languages
L1, L2, L3, et cetera.
--match-d=<regex> Only count files in directories matching the Perl
regex. For example
--match-d='/(src|include)/'
only counts files in directories containing
/src/ or /include/.
--not-match-d=<regex> Count all files except those in directories
matching the Perl regex.
--match-f=<regex> Only count files whose basenames match the Perl
regex. For example
--match-f='^[Ww]idget'
only counts files that start with Widget or widget.
--not-match-f=<regex> Count all files except those whose basenames
match the Perl regex.
--skip-archive=<regex> Ignore files that end with the given Perl regular
expression. For example, if given
--skip-archive='(zip|tar(.(gz|Z|bz2|xz|7z))?)'
the code will skip files that end with .zip,
.tar, .tar.gz, .tar.Z, .tar.bz2, .tar.xz, and
.tar.7z.
--skip-win-hidden On Windows, ignore hidden files.
Debug Options
--categorized=<file> Save names of categorized files to <file>.
--counted=<file> Save names of processed source files to <file>.
--explain=<lang> Print the filters used to remove comments for
language <lang> and exit. In some cases the
filters refer to Perl subroutines rather than
regular expressions. An examination of the
source code may be needed for further explanation.
--diff-alignment=<file> Write to <file> a list of files and file pairs
showing which files were added, removed, and/or
compared during a run with --diff. This switch
forces the --diff mode on.
--help Print this usage information and exit.
--found=<file> Save names of every file found to <file>.
--ignored=<file> Save names of ignored files and the reason they
were ignored to <file>.
--print-filter-stages Print processed source code before and after
each filter is applied.
--show-ext[=<ext>] Print information about all known (or just the
given) file extensions and exit.
--show-lang[=<lang>] Print information about all known (or just the
given) languages and exit.
--show-os Print the value of the operating system mode
and exit. See also --unix, --windows.
-v[=<n>] Verbose switch (optional numeric value).
--version Print the version of this program and exit.
--write-lang-def=<file> Writes to <file> the language processing filters
then exits. Useful as a first step to creating
custom language definitions (see also
--force-lang-def, --read-lang-def).
Output Options
--3 Print third-generation language output.
(This option can cause report summation to fail
if some reports were produced with this option
while others were produced without it.)
--by-percent X Instead of comment and blank line counts, show
these values as percentages based on the value
of X in the denominator:
X = 'c' -> # lines of code
X = 'cm' -> # lines of code + comments
X = 'cb' -> # lines of code + blanks
X = 'cmb' -> # lines of code + comments + blanks
For example, if using method 'c' and your code
has twice as many lines of comments as lines
of code, the value in the comment column will
be 200%. The code column remains a line count.
--csv Write the results as comma separated values.
--csv-delimiter=<C> Use the character <C> as the delimiter for comma
separated files instead of ,. This switch forces
--out=<file> Synonym for --report-file=<file>.
--csv to be on.
--progress-rate=<n> Show progress update after every <n> files are
processed (default <n>=100). Set <n> to 0 to
suppress progress output (useful when redirecting
output to STDOUT).
--quiet Suppress all information messages except for
the final report.
--report-file=<file> Write the results to <file> instead of STDOUT.
--sql=<file> Write results as SQL create and insert statements
which can be read by a database program such as
SQLite. If <file> is -, output is sent to STDOUT.
--sql-append Append SQL insert statements to the file specified
by --sql and do not generate table creation
statements. Only valid with the --sql option.
--sql-project=<name> Use <name> as the project identifier for the
current run. Only valid with the --sql option.
--sql-style=<style> Write SQL statements in the given style instead
of the default SQLite format. Currently, the
only style option is Oracle.
--sum-one For plain text reports, show the SUM: output line
even if only one input file is processed.
--xml Write the results in XML.
--xsl=<file> Reference <file> as an XSL stylesheet within
the XML output. If <file> is 1 (numeric one),
writes a default stylesheet, cloc.xsl (or
cloc-diff.xsl if --diff is also given).
This switch forces --xml on.
--yaml Write the results in YAML.
Распознаваемые языки
prompt> cloc --show-lang ABAP (abap) ActionScript (as) Ada (ada, adb, ads, pad) ADSO/IDSM (adso) AMPLE (ample, dofile, startup) Ant (build.xml) Apex Trigger (trigger) Arduino Sketch (ino, pde) ASP (asa, asp) ASP.Net (asax, ascx, asmx, aspx, config, master, sitemap, webinfo) Assembly (asm, s, S) AutoHotkey (ahk) awk (awk) Bourne Again Shell (bash) Bourne Shell (sh) C (c, ec, pgc) C Shell (csh, tcsh) C# (cs) C++ (C, c++, cc, cpp, cxx, pcc) C/C++ Header (h, H, hh, hpp) CCS (ccs) Clojure (clj) ClojureScript (cljs) CMake (cmake, CMakeLists.txt) COBOL (cbl, CBL, cob, COB) CoffeeScript (coffee) ColdFusion (cfm) ColdFusion CFScript (cfc) CSS (css) CUDA (cu) Cython (pyx) D/dtrace (d) DAL (da) Dart (dart) diff (diff) DITA (dita) DOS Batch (bat, BAT, btm, BTM, cmd, CMD) DTD (dtd) ECPP (ecpp) Elixir (ex, exs) ERB (ERB, erb) Erlang (erl, hrl) Expect (exp) F# (fs, fsi) Focus (focexec) Fortran 77 (f, F, f77, F77, for, FOR, FTN, ftn, pfo) Fortran 90 (f90, F90) Fortran 95 (f95, F95) Go (go) Grails (gsp) Groovy (gant, gradle, groovy) Haml (haml) Handlebars (handlebars, hbs) Harbour (hb) Haskell (hs, lhs) HLSL (cg, cginc, shader) HTML (htm, html) IDL (idl) IDL/Qt Project/Prolog (pro) InstallShield (ism) Java (java) Javascript (js) JavaServer Faces (jsf, xhtml) JCL (jcl) JSON (json) JSP (jsp, jspf) Kermit (ksc) Korn Shell (ksh) Kotlin (kt) LESS (less) lex (l) Lisp (el, lisp, lsp, sc) Lisp/Julia (jl) Lisp/OpenCL (cl) LiveLink OScript (oscript) Lua (lua) m4 (ac, m4) make (am, gnumakefile, Gnumakefile, makefile, Makefile) MATLAB (m) Maven (pom, pom.xml) Modula3 (i3, ig, m3, mg) MSBuild script (csproj, vbproj, vcproj, wdproj, wixproj) MUMPS (mps, m) Mustache (mustache) MXML (mxml) NAnt script (build) NASTRAN DMAP (dmap) Objective C (m) Objective C++ (mm) OCaml (ml, mli, mll, mly) Oracle Forms (fmt) Oracle Reports (rex) Pascal (dpr, p, pas) Pascal/Puppet (pp) Patran Command Language (pcl, ses) Perl (perl, plh, plx, pm) Perl/Prolog (PL, pl) PHP (php, php3, php4, php5) PHP/Pascal (inc) Pig Latin (pig) PL/I (pl1) PowerShell (ps1) Prolog (P) Protocol Buffers (proto) PureScript (purs) Python (py) QML (qml) R (R) Racket (rkt, rktl, sch, scm, scrbl, ss) Razor (cshtml) Rexx (rexx) RobotFramework (robot, tsv) Ruby (rake, rb) Ruby HTML (rhtml) Rust (rs) SAS (sas) SASS (sass, scss) Scala (scala) sed (sed) SKILL (il) SKILL++ (ils) Smarty (smarty, tpl) Softbridge Basic (sbl, SBL) SQL (psql, sql, SQL) SQL Data (data.sql) SQL Stored Procedure (spc.sql, spoc.sql, sproc.sql, udf.sql) Standard ML (fun, sig, sml) Swift (swift) Tcl/Tk (itk, tcl, tk) Teamcenter met (met) Teamcenter mth (mth) Titanium Style Sheet (tss) TypeScript (ts) Unity-Prefab (mat, prefab) Vala (vala) Vala Header (vapi) Velocity Template Language (vm) Verilog-SystemVerilog (sv, svh, v) VHDL (VHD, vhd, vhdl, VHDL) vim script (vim) Visual Basic (bas, cls, ctl, dsr, frm, VB, vb, VBA, vba, vbs, VBS) Visual Fox Pro (sca, SCA) Visualforce Component (component) Visualforce Page (page) Windows Message File (mc) Windows Module Definition (def) Windows Resource File (rc, rc2) WiX include (wxi) WiX source (wxs) WiX string localization (wxl) XAML (xaml) xBase (prg) xBase Header (ch) XML (XML, xml) XQuery (xq, xquery) XSD (xsd, XSD) XSLT (xsl, XSL, xslt, XSLT) yacc (y) YAML (yaml, yml)
Выше список может быть изменен, читая определения языка из файла с --read-lang-def или --force-lang-def вариантов.
Восемь расширений файлов есть несколько сопоставлений языка:
• .cl файлы могут быть Lisp или OpenCL
• .INC файлы могут быть PHP или Pascal
• .jl файлы могут быть Lisp или Julia
• .m файлы могут быть MATLAB, Mercury, MUMPS, или Objective C
• .P файлы могут быть D или DTrace
• .pl файлы могут быть Perl или Prolog
• .PP файлы могут быть Pascal или Puppet
• .pro файлы могут быть IDL, Prolog, или Qt Project
Cloc имеет подпрограммы, которые пытаются определить правильный язык, основанный на содержимое файла для этих особых случаев. Точность идентификации Язык функция, как много кода файл содержит; .m файлы с помощью всего одного или двух линий, например, редко имеют достаточно информации, чтобы правильно различать MATLAB, Меркурий, эпидемического паротита, или Objective C.
Языки с расширением файла столкновений трудно настроить с --read-lang-def четкости или --force-lang-def четкости, поскольку они не имеют никакого механизма для выявления языки с общими расширений. В этой ситуации необходимо изменить исходный код Cloc.
Как это работает
Метод Cloc о работе напоминает SLOCCount: во-первых, создать список файлов, чтобы рассмотреть. Далее, попытка определить, является ли или не найден файлы содержат признанный источник компьютерный язык кода. Наконец, для файлов, определенных как исходных файлов, вызовите конкретного языка процедуры, чтобы подсчитать количество строк исходного кода.
Более подробное описание:
1. Если входной файл архива (например, .tar.gz или .zip), создать временный каталог и развернуть архив есть с помощью системного вызова к соответствующему основной утилиты (tar, bzip2, unzip, и т.д.), то добавить Этот временный каталог в качестве одного из входов. (Это работает более надежно на Unix, чем на Windows.)
2. �?спользуйте File::Find рекурсивно спускаться входные каталоги и составьте список имен файлов кандидат. �?гнорировать двойных и нулевого размера файлов.
3. Убедитесь, что файлы в списке кандидата есть уникальные содержание (первый, сравнивая размеры файлов, то для тех же размеров файлов, сравнить MD5 хэши содержимого файлов с Digest::MD5). Для каждого набора одинаковых файлов, удалить все, кроме первой копии, как определено в лексической рода, одинаковых файлов из набора. Снятые файлы не включены в отчет. (Переключатель --skip-uniqueness отключает тесты уникальность и заставляет все копии файлов, которые будут включены в отчет.) См также --ignored= переключатель, чтобы увидеть, какие файлы были проигнорированы, и почему.
4. Просмотрите список кандидатов файла расширений файлов, которые Cloc ассоциируется с языками программирования (см --show-lang и --show-ext варианты). Файлы, которые соответствуют классифицируются как содержащие исходный код для данного языка. Каждый файл без расширения открывается и его первая строка чтения, чтобы увидеть, если это сценарий оболочки Unix (все, что начинается с #!). Если это сценарий оболочки, файл классифицируется этой языком сценариев (если язык признан). Если файл не имеет признанного расширение или не recognzied скриптовый язык, файл игнорируется.
5. Теперь все остальные файлы в списке кандидата должны быть исходные файлы для известных языков программирования. Для каждого из этих файлов:
1. Читайте весь файл в память.
2. Подсчитайте количество строк (=Loriginal).
3. Удалить пустые строки, то рассчитывать снова (=Lnon_blank).
4. Петлю на комментарий фильтров, определенных для этого языка. (Например, в C ++ имеет два фильтра: (1) удалить строки, которые начинаются с дополнительным пробелом с последующей // и (2) удалить текст между /* и */) применить каждый фильтр к коду, чтобы удалить комментарии. Граф оставшиеся линии (=Lcode).
5. Сохранить расчеты для этого языка:
пустые строки = Loriginal - Lnon_blank
строки комментариев = Lnon_blank - Lcode
строки кода = Lcode
Варианты изменить алгоритм немного. Опция --read-lang-def, например, позволяет пользователю читать определения комментарий фильтров, известных расширений файлов и известных языков сценариев из файла. Код для этой опции обрабатывается между шагами 2 и 3.
Расширенное использование
Удаление комментариев из исходного кода
Как вы можете сказать, если Cloc правильно определяет комментарии? Один из способов, чтобы убедить себя Cloc делает правильную вещь, чтобы использовать его --strip-comments опцию чтобы удалить комментарии и пустые строки из файлов, а затем сравнить урезанная файлы оригиналов.
Давайте попробуем это с SQLite amalgamation, С файл, содержащий все код, необходимый для построения SQLite библиотеки вместе с файлом заголовка:
prompt> tar zxf sqlite-amalgamation-3.5.6.tar.gz
prompt> cd sqlite-3.5.6/
prompt> cloc --strip-comments=nc sqlite.c
1 text file.
1 unique file.
Wrote sqlite3.c.nc
0 files ignored.
http://https://github.com v 1.03 T=1.0 s (1.0 files/s, 82895.0 lines/s)
-------------------------------------------------------------------------------
Language files blank comment code scale 3rd gen. equiv
-------------------------------------------------------------------------------
C 1 5167 26827 50901 x 0.77 = 39193.77
-------------------------------------------------------------------------------
Аргумент продление дается --strip-comments произвольно; здесь nc был использован как сокращение для "без комментариев".
Cloc удалил более 31000 строк из файла:
prompt> wc -l sqlite3.c sqlite3.c.nc 82895 sqlite3.c 50901 sqlite3.c.nc 133796 total prompt> echo "82895 - 50901" | bc 31994
Теперь мы можем сравнить orignial файл, sqlite3.c и один зачищенный комментариев, sqlite3.c.nc с инструментами, как дифф или vimdiff и посмотреть, что именно считается Cloc комментарии и пустые строки. Строгое доказательство, что урезанная файл содержит тот же код C как оригинал, чтобы обобщить эти файлы и сравнить контрольные суммы полученных объектных файлов.
Во-первых, оригинальный источник файла:
prompt> gcc -c sqlite3.c prompt> md5sum sqlite3.o cce5f1a2ea27c7e44b2e1047e2588b49 sqlite3.o
Далее, версия без комментариев:
prompt> mv sqlite3.c.nc sqlite3.c prompt> gcc -c sqlite3.c prompt> md5sum sqlite3.o cce5f1a2ea27c7e44b2e1047e2588b49 sqlite3.o
Cloc удалил более 31000 строк комментариев и пробелов, но не изменять исходный код в любом существенным образом, поскольку в результате объектный файл соответствует оригиналу.
Работа с сжатыми архивами
Версии Cloc до v1.07 требовала --extract-with= опцию возможность рассказать Cloc как расширить архивный файл. Начиная с v1.07 это добыча попытка автоматически. В настоящее время способ автоматического извлечения работает достаточно хорошо на Unix-типа OS для следующих типов файлов: .tar.gz, .tar.bz2, .tgz, .zip, .ear. Некоторые из этих расширений работать на Windows, если один WinZip установлен в папку по умолчанию (C:\Program Files\WinZip\WinZip32.exe). Кроме того, с более новыми версиями WinZip, дополнения командной строки необходимы для правильной работы; в этом случае можно было бы ссылаться Cloc что-то вроде
--extract-with="\"c:\Program Files\WinZip\wzunzip\" -e -o >FILE< ." (см. сообщение в форуме).
В ситуациях, когда автоматическое извлечение не удается, можно попробовать вариант --extract-with= опцию для подсчета строк кода в битуминозных файлов, Zip файлов, или других сжатых архивов для которых имеет инструмент для извлечения. Cloc принимает команду извлечения пользователем при условии, и расширяет архив во временную директорию (созданной с File::Temp), подсчитывает строки кода во временном каталоге, а затем удаляет этот каталог. В то время как не особенно полезно при работе с одной сжатого архива (в конце концов, если вы собираетесь в любом случае введите команду извлечения, почему не просто вручную развернуть архив?) Эта опция удобна для работы с несколькими архивами одновременно.
Например, у вас есть следующие исходные архивы на машине Unix:
perl-5.8.5.tar.gz
Python-2.4.2.tar.gz
и вы хотите подсчитать весь код внутри них. Команда будет следующая:
cloc --extract-with='gzip -dc >FILE< | tar xf -' perl-5.8.5.tar.gz Python-2.4.2.tar.gz
Если Unix машина имеет GNU tar (который может распаковать и извлечь в один прием) команда может быть сокращен до
cloc --extract-with='tar zxf >FILE<' perl-5.8.5.tar.gz Python-2.4.2.tar.gz
На компьютере Windows, с помощью WinZip, установленной в c:\Program Files\WinZip команда будет выглядеть так:
cloc.exe --extract-with="\"c:\Program Files\WinZip\WinZip32.exe\" -e -o >FILE< ." perl-5.8.5.tar.gz Python-2.4.2.tar.gz
Java .ear файлы Zip-файлы, которые содержат дополнительные файлы Zip. Cloc может обрабатывать вложенные в сжатые архивы без труда - при условии, все такие файлы сжимаются и сохраняются в том же пути. Примеры подсчета .ear файл Java в Unix и Windows:
Unix> cloc --extract-with="unzip -d . >FILE< " Project.ear DOS> cloc.exe --extract-with="\"c:\Program Files\WinZip\WinZip32.exe\" -e -o >FILE< ." Project.ear
Различия
--diff переключатель позволяет измерять относительное изменение исходного кода и комментарии между двумя версиями файла, каталога или архива. Различия выявить гораздо больше, чем абсолютных кода пунктам двух версий файлов. Например, сказать, исходный файл имеет 100 строк и его разработчик поставляет новую версию с 102 линий. Он добавьте две строки комментариев, или удалить семнадцать строк исходного и добавить четырнадцать исходные линии и пять строк комментариев, или он сделал полный рерайт, отбрасывая все 100 оригинальных линий и добавления линии 102 всех новых источников? Опция разн рассказывает, как были добавлены многие линии источника, удаляется, изменения или остались же, как и были добавлены многие линии комментариев, удалены, изменены или остались прежними.
В дополнение к пар файлов, можно дать Cloc пары каталогов или пары файловых архивов, или файловый архив и каталог. Cloc будет пытаться выровнять пары файлов в пределах каталогов или архивов и сравнить различия для каждой пары. Например, чтобы посмотреть, что изменилось между GCC 4.4.0 и 4.5.0 можно сделать
cloc --diff gcc-4.4.0.tar.bz2 gcc-4.5.0.tar.bz2
Будьте готовы подождать за результаты, хотя; --diff вариант работает гораздо медленнее, чем абсолютное число кода.
Чтобы увидеть, как Cloc выравнивает файлы между двумя архивами, использовать --diff-alignment опцию
cloc --diff-aligment=align.txt gcc-4.4.0.tar.bz2 gcc-4.5.0.tar.bz2
для получения файла align.txt который показывает файл пары, а также файлы, добавленные и удаленные. Символы == и != перед каждым пары файлов указать, если файлы идентичны (==), или если они имеют различное содержание (!=).
Вот пример вывода, показывающий разницу между Python релизами 2.6.6 и 2.7:
prompt> cloc --diff Python-2.6.6.tar.bz2 Python-2.7.tar.bz2
3870 text files.
4130 text files.s
2177 files ignored.
2 errors:
Diff error (quoted comments?): /tmp/4QAqkrHN7Z/Python-2.6.6/Mac/Modules/qd/qdsupport.py
Diff error (quoted comments?): /tmp/LvStB1lQxd/Python-2.7/Mac/Modules/qd/qdsupport.py
http://https://github.com v 1.52 T=422.0 s (0.0 files/s, 0.0 lines/s)
-------------------------------------------------------------------------------
Language files blank comment code
-------------------------------------------------------------------------------
vim script
same 0 0 7 85
modified 1 0 0 20
added 0 0 0 1
removed 0 0 0 0
Expect
same 1 0 0 60
modified 0 0 0 0
added 6 0 0 0
removed 0 0 0 0
CSS
same 1 0 19 318
modified 0 0 0 0
added 0 0 0 0
removed 0 0 0 0
XML
same 1 0 0 4
modified 0 0 0 0
added 3 0 0 0
removed 1 0 0 0
m4
same 1 0 19 1089
modified 2 0 0 130
added 5 6 5 150
removed 0 660 15 5905
Visual Basic
same 2 0 1 12
modified 0 0 0 0
added 0 0 0 0
removed 0 0 0 0
Lisp
same 1 0 503 2933
modified 0 0 0 0
added 0 0 0 0
removed 0 0 0 0
NAnt scripts
same 2 0 0 30
modified 0 0 0 0
added 0 0 0 0
removed 0 0 0 0
HTML
same 12 0 11 2329
modified 2 0 0 2
added 0 0 0 0
removed 9 0 0 0
make
same 3 0 353 2888
modified 7 0 3 11
added 2 1 0 14
removed 0 2 0 8
Objective C
same 6 0 70 633
modified 1 0 0 2
added 0 0 0 0
removed 0 0 0 0
Assembly
same 22 0 1575 9156
modified 14 0 78 174
added 3 171 111 998
removed 2 1 0 189
Bourne Shell
same 26 0 2828 20114
modified 7 0 255 2179
added 5 163 1103 4770
removed 0 550 2444 11660
(unknown)
same 0 0 0 0
modified 0 0 0 0
added 32 0 0 0
removed 26 0 0 0
C++
same 0 0 0 0
modified 0 0 0 0
added 2 0 0 0
removed 0 0 0 0
Teamcenter def
same 6 0 158 885
modified 2 0 0 0
added 1 2 4 17
removed 1 0 4 2
DOS Batch
same 26 0 101 416
modified 5 0 1 8
added 1 0 0 0
removed 0 0 0 0
C/C++ Header
same 143 0 9016 37452
modified 90 0 157 15564
added 12 181 341 10247
removed 1 101 129 5219
C
same 222 0 28753 322642
modified 157 0 542 5023
added 141 1485 1730 12440
removed 4 223 619 4519
Python
same 1211 0 92289 348923
modified 740 0 1238 11589
added 114 2845 4645 17251
removed 23 1409 2617 6385
-------------------------------------------------------------------------------
SUM:
same 1686 0 135703 749969
modified 1028 0 2274 34702
added 327 4854 7939 45888
removed 67 2946 5828 33887
-------------------------------------------------------------------------------
Обратите внимание на две ошибки для файла Python-X/Mac/Modules/qd/qdsupport.py. Этот файл имеет Python строки документации (текст между парами тройных кавычек), которые содержат C комментарии. Cloc лечит строки документации как комментарии и обрабатывает их сначала преобразовать их в С комментариями, то с помощью C комментарий удаление регулярное выражение. Вложенные комментарии C провоцировать ошибочные результаты, однако.
Там также выход для языка "(неизвестного)". Файлы в этой категории не являются исходные файлы, и поэтому не учитываются; их присутствие лишь отметить, как будто они были удалены, добавлены или модифицированы.
Создание пользовательских определений языка
Cloc можете написать свои определения языка комментарий к файлу или можете прочитать определения комментарий из файла, перекрывая встроенные определения. Это может быть полезно, когда вы хотите использовать Cloc рассчитывать линии языке еще не включены, чтобы изменить ассоциации расширений файлов с языками, или изменить способ существующих языков подсчитываются.
Самый простой способ для создания пользовательского файла определения языка, чтобы сделать Cloc написать свои определения в файл, а затем изменить файл:
Unix> cloc --write-lang-def=my_definitions.txt
создает файл my_definitions.txt, которые могут быть изменены, то читать еще в ни --read-lang-def или --force-lang-def опцию. Разница между вариантами бывший определения слияния языка из данного файла с использованием внутренних определений Cloc с cloc'taking приоритет, если есть совпадения. Опция --force-lang-def, с другой стороны, заменяет определения Cloc совершенно. Эта опция имеет недостаток в предотвращении Cloc от подсчета языков чья расширенная карта имеет несколько языков, так как эти языки требуют дополнительной логики, которая не может быть выражена в файлах описаний.
Unix> cloc --read-lang-def=my_definitions.txt file1 file2 dir1 ...
Каждая запись в языке состоит из четырех частей:
1. Название языка, начиная с колонки 1.
2. Один или несколько фильтров комментариев, начиная в колонке 5.
3. Один или несколько расширений имен файлов, начинающиеся в колонке 5.
4. Коэффициент 3 шкала поколение, начиная с колонки 5. Эта запись должна быть предоставлена, но его значение не важно, если вы не хотите, чтобы сравнить язык в гипотетической языке программирования третьего поколения.
Фильтр определяет метод удаления текста комментария из исходного файла. Например вход для C ++ выглядит так:
C++
filter remove_matches ^\s*//
filter call_regexp_common C
extension C
extension cc
extension cpp
extension cxx
extension pcc
3rd_gen_scale 1.51
C++ имеет два фильтра: во-первых, удалить строки, которые начинаются с дополнительным пробелом и последующим //. Затем удалите все комментарии C. C комментарии трудно выразить, как регулярные выражения, чтобы вызов на Regexp::Common, чтобы получить соответствующую регулярное выражение, чтобы соответствовать C комментарии, которые затем удаляются.
Более полное обсуждение различных вариантов фильтров может появиться здесь в будущем. Выход опции --write-lang-def Cloc должны обеспечить достаточное количество примеров для мотивированных людей, чтобы изменить или расширить определения языка Cloc.
Объединенные отчеты
Если вы управляете несколькими проектами программного обеспечения вы можете быть заинтересованы в том, счетчики линии по проекту, а не только по языку. Скажем, вы управлять три программных проектов называемые MySQL, PostgreSQL, и SQLite. Команды, отвечающие за каждый из этих проектов запустить Cloc на их исходного кода и предоставить Вам с выходом. Например команда MySQL делает:
cloc --report-file=mysql-5.1.42.txt mysql-5.1.42.tar.gz
и снабжает вас файловом mysql-5.1.42.txt. Содержание из трех файлов вы получаете такое:
Unix> cat mysql-5.1.42.txt http://https://github.com v 1.50 T=26.0 s (108.1 files/s, 65774.5 lines/s) -------------------------------------------------------------------------------- Language files blank comment code -------------------------------------------------------------------------------- C++ 615 93609 110909 521041 C 642 83179 82424 393602 C/C++ Header 1065 33980 77633 142779 Bourne Shell 178 14892 11437 74525 Perl 60 7634 4667 22703 m4 13 1220 394 10497 make 119 914 1855 4447 XML 27 564 23 4107 SQL 18 517 209 3433 Assembly 12 161 0 1304 yacc 2 167 40 1048 lex 2 332 113 879 Teamcenter def 43 85 219 701 Javascript 3 70 140 427 Pascal 2 0 436 377 HTML 1 7 0 250 Bourne Again Shell 1 6 1 48 DOS Batch 8 23 73 36 -------------------------------------------------------------------------------- SUM: 2811 237360 290573 1182204 -------------------------------------------------------------------------------- Unix> cat sqlite-3.6.22.txt http://https://github.com v 1.50 T=3.0 s (4.7 files/s, 53833.7 lines/s) ------------------------------------------------------------------------------- Language files blank comment code ------------------------------------------------------------------------------- C 2 7459 37993 68944 Bourne Shell 7 3344 4522 25849 m4 2 754 20 6557 C/C++ Header 2 155 4808 1077 make 1 6 0 13 ------------------------------------------------------------------------------- SUM: 14 11718 47343 102440 ------------------------------------------------------------------------------- Unix> cat postgresql-8.4.2.txt http://https://github.com v 1.50 T=16.0 s (129.1 files/s, 64474.9 lines/s) ------------------------------------------------------------------------------- Language files blank comment code ------------------------------------------------------------------------------- C 923 102324 167390 563865 C/C++ Header 556 9180 22723 40990 Bourne Shell 51 3692 3245 28486 SQL 260 8246 5645 25862 yacc 6 2667 2126 22825 Perl 36 782 696 4894 lex 8 708 1525 3638 make 180 1215 1385 3453 m4 12 199 25 1431 Teamcenter def 13 4 0 1104 HTML 2 94 1 410 DOS Batch 7 53 22 188 XSLT 5 41 30 111 Assembly 3 17 0 105 D 1 14 14 65 CSS 1 16 7 44 sed 1 1 7 15 Python 1 5 1 12 ------------------------------------------------------------------------------- SUM: 2066 129258 204842 697498 -------------------------------------------------------------------------------
В то время как эти три файла интересно, вы также хотите, чтобы увидеть объединенные рассчитывает из всех проектов. Это может быть сделано с Cloc опцией --sum_reports:
Unix> cloc --sum-reports --report_file=databases mysql-5.1.42.txt postgresql-8.4.2.txt sqlite-3.6.22.txt Wrote databases.lang Wrote databases.file
Сочетание отчет производит два выходных файлов, один для сумм по языку программирования (databases.lang) и один проект (databases.file). �?х содержание следующие:
Unix> cat databases.lang http://https://github.com v 1.50 -------------------------------------------------------------------------------- Language files blank comment code -------------------------------------------------------------------------------- C 1567 192962 287807 1026411 C++ 615 93609 110909 521041 C/C++ Header 1623 43315 105164 184846 Bourne Shell 236 21928 19204 128860 SQL 278 8763 5854 29295 Perl 96 8416 5363 27597 yacc 8 2834 2166 23873 m4 27 2173 439 18485 make 300 2135 3240 7913 lex 10 1040 1638 4517 XML 27 564 23 4107 Teamcenter def 56 89 219 1805 Assembly 15 178 0 1409 HTML 3 101 1 660 Javascript 3 70 140 427 Pascal 2 0 436 377 DOS Batch 15 76 95 224 XSLT 5 41 30 111 D 1 14 14 65 Bourne Again Shell 1 6 1 48 CSS 1 16 7 44 sed 1 1 7 15 Python 1 5 1 12 -------------------------------------------------------------------------------- SUM: 4891 378336 542758 1982142 -------------------------------------------------------------------------------- Unix> cat databases.file ---------------------------------------------------------------------------------- Report File files blank comment code ---------------------------------------------------------------------------------- mysql-5.1.42.txt 2811 237360 290573 1182204 postgresql-8.4.2.txt 2066 129258 204842 697498 sqlite-3.6.22.txt 14 11718 47343 102440 ---------------------------------------------------------------------------------- SUM: 4891 378336 542758 1982142 ----------------------------------------------------------------------------------
Сообщить файлы сами по себе могут быть суммируются. Скажем, вы также управлять развития Perl и Python, и вы хотите, чтобы отслеживать тех, линия насчитывает отдельно от проектов баз данных. Во-первых, создание отчетов за Perl и Python отдельно:
cloc --report-file=perl-5.10.0.txt perl-5.10.0.tar.gz cloc --report-file=python-2.6.4.txt Python-2.6.4.tar.bz2
затем сложить их вместе
Unix> cloc --sum-reports --report_file=script_lang perl-5.10.0.txt python-2.6.4.txt Wrote script_lang.lang Wrote script_lang.file Unix> cat script_lang.lang http://https://github.com v 1.50 ------------------------------------------------------------------------------- Language files blank comment code ------------------------------------------------------------------------------- C 518 61871 52705 473034 Python 1965 76022 95289 365716 Perl 2052 110356 130018 292281 C/C++ Header 381 13762 21402 102276 Bourne Shell 149 9376 11665 81508 Lisp 2 1154 2745 10448 Assembly 38 1616 1712 9755 m4 3 825 34 7124 make 16 954 804 4829 HTML 25 516 13 3010 Teamcenter def 9 170 162 2075 XML 28 288 0 2034 C++ 10 312 277 2000 yacc 2 128 97 1549 DOS Batch 42 175 152 746 Objective C 7 102 70 635 YAML 2 2 0 489 CSS 1 94 19 308 vim script 1 36 7 105 Expect 1 0 0 60 NAnt scripts 2 1 0 30 Visual Basic 2 1 1 12 ------------------------------------------------------------------------------- SUM: 5256 277761 317172 1360024 ------------------------------------------------------------------------------- Unix> cat script_lang.file ------------------------------------------------------------------------------- Report File files blank comment code ------------------------------------------------------------------------------- python-2.6.4.txt 2746 135676 143269 830347 perl-5.10.0.txt 2510 142085 173903 529677 ------------------------------------------------------------------------------- SUM: 5256 277761 317172 1360024 -------------------------------------------------------------------------------
Наконец, объединить комбинации файлов:
Unix> cloc --sum-reports --report_file=everything databases.lang script_lang.lang Wrote everything.lang Wrote everything.file Unix> cat everything.lang http://https://github.com v 1.50 -------------------------------------------------------------------------------- Language files blank comment code -------------------------------------------------------------------------------- C 2085 254833 340512 1499445 C++ 625 93921 111186 523041 Python 1966 76027 95290 365728 Perl 2148 118772 135381 319878 C/C++ Header 2004 57077 126566 287122 Bourne Shell 385 31304 30869 210368 SQL 278 8763 5854 29295 m4 30 2998 473 25609 yacc 10 2962 2263 25422 make 316 3089 4044 12742 Assembly 53 1794 1712 11164 Lisp 2 1154 2745 10448 XML 55 852 23 6141 lex 10 1040 1638 4517 Teamcenter def 65 259 381 3880 HTML 28 617 14 3670 DOS Batch 57 251 247 970 Objective C 7 102 70 635 YAML 2 2 0 489 Javascript 3 70 140 427 Pascal 2 0 436 377 CSS 2 110 26 352 XSLT 5 41 30 111 vim script 1 36 7 105 D 1 14 14 65 Expect 1 0 0 60 Bourne Again Shell 1 6 1 48 NAnt scripts 2 1 0 30 sed 1 1 7 15 Visual Basic 2 1 1 12 -------------------------------------------------------------------------------- SUM: 10147 656097 859930 3342166 -------------------------------------------------------------------------------- Unix> cat everything.file ------------------------------------------------------------------------------- Report File files blank comment code ------------------------------------------------------------------------------- databases.lang 4891 378336 542758 1982142 script_lang.lang 5256 277761 317172 1360024 ------------------------------------------------------------------------------- SUM: 10147 656097 859930 3342166 -------------------------------------------------------------------------------
SQL
Cloc может записать результаты в виде таблицы SQL создать и вставить заявления для использования с реляционными базами данных программ, таких как SQLite, MySQL, PostgreSQL, Oracle, Microsoft SQL или. После того, как информация Количество код в базе данных, информация может быть допрошен и отображаются в интересных способов.
База данных, созданная Cloc и выведенная в SQL имеет две таблицы, metadata и t:
metadata
|
t
|
Таблица metadata содержит информацию о том, когда был сделан Cloc выполнения. Переключатель --sql-append позволяет объединить множество трасс в единой базе данных; при каждом запуске добавляет строку в таблицу метаданных. �?нформация подсчет код находится в таблице t.
Давайте повторим примеры подсчета кода Perl, Python, SQLite, MySQL и PostgreSQL архивы, показанные в примере объединенных отчетов выше, на этот раз с помощью опции вывода SQL и движок базы данных SQLite.
--sql переключатель указывает Cloc генерировать вывод в виде таблицы SQL create и insert команды. Переключатель принимает аргумент имени файла, чтобы написать эти SQL заявления в, или, если аргумент 1 (числовое один), ручьи вывод STDOUT. С SQLite программы командной строки, sqlite3, можете прочитать команды из стандартного ввода, мы можем обойтись без хранения SQL заявления в файл и использовать --sql 1 к данным труб непосредственно в исполняемый файл SQLite:
cloc --sql 1 --sql-project mysql mysql-5.1.42.tar.gz | sqlite3 code.db
--sql-project mysql часть является необязательной; нет необходимости указывать название проекта, когда работать только с одной базой кода. Однако, поскольку мы будем добавлять счетчики кода из четырех других тарболов мы будем только в состоянии определить данные, источник входного сигнала, если мы поставляем имя проекта для каждого прогона.
Теперь у нас есть база данных нам нужно будет пройти в коммутаторе --sql-append дописывания сказать Cloc не уничтожить эту базу данных, но вместо того, чтобы добавить больше данных:
cloc --sql 1 --sql-project postgresql --sql-append postgresql-8.4.2.tar.bz2 | sqlite3 code.db cloc --sql 1 --sql-project sqlite --sql-append sqlite-amalgamation-3.6.22.tar.gz | sqlite3 code.db cloc --sql 1 --sql-project python --sql-append Python-2.6.4.tar.bz2 | sqlite3 code.db cloc --sql 1 --sql-project perl --sql-append perl-5.10.0.tar.gz | sqlite3 code.db
Теперь начинается самое интересное - у нас есть базы данных, code.db, с большим количеством информации о пяти проектов и может начать его запросов для всяких интересных фактов.
Какой был самый длинный файл среди всех проектов?
> sqlite3 code.db 'select project,file,nBlank+nComment+nCode as nL from t where nL = (select max(nBlank+nComment+nCode) from t)' sqlite|sqlite-3.6.22/sqlite3.c|110860
Формат вывода по умолчанию sqlite3 оставляет желать лучшего. Мы можем добавить опцию в файл гс программы, ~/.sqliterc, чтобы показать заголовки столбцов:
.header on
Один может возникнуть соблазн также
.mode column
в ~/.sqliterc но это вызывает проблемы, когда выход имеет более чем одну строку, так как ширина записей в первой строке регулируют максимальную ширину для всех последующих рядов. Часто это приводит к усеченной выходе - совсем не желательны. Одним из вариантов является, чтобы написать выходной форматирования пользовательских данных SQLite, таких как sqlite_formatter. Он используется так:
> sqlite3 code.db 'select project,file,nBlank+nComment+nCode as nL from t where nL = (select max(nBlank+nComment+nCode) from t)' | sqlite_formatter Project File nL _______ _______________________ ______ sqlite sqlite-3.6.22/sqlite3.c 110860
Отметим также, что sqlite3 имеет опцию вывода HTML, --html, что также может оказаться полезным.
Какой бывает самый длинный файл в каждом проекте?
> sqlite3 code.db 'select project,file,max(nBlank+nComment+nCode) as nL from t group by project order by nL;' | sqlite_formatter Project File nL __________ _____________________________________________ ______ perl perl-5.10.0/t/op/mkdir.t 22658 python Python-2.6.4/Lib/email/quoprimime.py 28091 postgresql postgresql-8.4.2/contrib/pgcrypto/pgp-pgsql.c 40041 mysql mysql-5.1.42/netware/mysqldump.def 51841 sqlite sqlite-3.6.22/config.sub 110860
Какие файлы в каждом проекте имеют больше всего строк кода?
> sqlite3 code.db 'select project,file,max(nCode) as nL from t group by project order by nL desc;' | sqlite_formatter Project File nL __________ _____________________________________________ _____ sqlite sqlite-3.6.22/config.sub 66142 mysql mysql-5.1.42/netware/mysqldump.def 38555 postgresql postgresql-8.4.2/contrib/pgcrypto/pgp-pgsql.c 36905 python Python-2.6.4/Lib/email/quoprimime.py 26705 perl perl-5.10.0/t/op/mkdir.t 20079
Какие исходные файлы С с количеством линий более 300 имеют соотношение комментариев ниже 1%?
> sqlite3 code.db 'select project, language, file, nCode, nComment, (100.0*nComment)/(nComment+nCode) as comment_ratio from t where language="C" and nCode > 300 and comment_ratio < 1 order by comment_ratio;' | sqlite_formatter Project Language File nCode nComment comment_ratio __________ ________ _____________________________________________________________________________ _____ ________ __________________ mysql C mysql-5.1.42/scripts/mysql_fix_privilege_tables_sql.c 658 0 0.0 python C Python-2.6.4/Python/graminit.c 2143 1 0.0466417910447761 postgresql C postgresql-8.4.2/src/backend/snowball/libstemmer/stem_UTF_8_turkish.c 2095 1 0.0477099236641221 postgresql C postgresql-8.4.2/src/backend/snowball/libstemmer/stem_UTF_8_french.c 1211 1 0.0825082508250825 postgresql C postgresql-8.4.2/src/backend/snowball/libstemmer/stem_ISO_8859_1_french.c 1201 1 0.0831946755407654 postgresql C postgresql-8.4.2/src/backend/snowball/libstemmer/stem_UTF_8_hungarian.c 1182 1 0.084530853761623 postgresql C postgresql-8.4.2/src/backend/snowball/libstemmer/stem_ISO_8859_1_hungarian.c 1178 1 0.0848176420695505 postgresql C postgresql-8.4.2/src/backend/snowball/libstemmer/stem_UTF_8_english.c 1072 1 0.0931966449207828 postgresql C postgresql-8.4.2/src/backend/snowball/libstemmer/stem_ISO_8859_1_english.c 1064 1 0.0938967136150235 postgresql C postgresql-8.4.2/src/backend/snowball/libstemmer/stem_UTF_8_spanish.c 1053 1 0.094876660341556 postgresql C postgresql-8.4.2/src/backend/snowball/libstemmer/stem_ISO_8859_1_spanish.c 1049 1 0.0952380952380952 postgresql C postgresql-8.4.2/src/backend/snowball/libstemmer/stem_UTF_8_italian.c 1031 1 0.0968992248062016 postgresql C postgresql-8.4.2/src/backend/snowball/libstemmer/stem_ISO_8859_1_italian.c 1023 1 0.09765625 postgresql C postgresql-8.4.2/src/backend/snowball/libstemmer/stem_UTF_8_portuguese.c 981 1 0.10183299389002 postgresql C postgresql-8.4.2/src/backend/snowball/libstemmer/stem_ISO_8859_1_portuguese.c 975 1 0.102459016393443 postgresql C postgresql-8.4.2/src/backend/snowball/libstemmer/stem_UTF_8_romanian.c 967 1 0.103305785123967 postgresql C postgresql-8.4.2/src/backend/snowball/libstemmer/stem_ISO_8859_2_romanian.c 961 1 0.103950103950104 postgresql C postgresql-8.4.2/src/backend/snowball/libstemmer/stem_UTF_8_finnish.c 720 1 0.13869625520111 postgresql C postgresql-8.4.2/src/backend/snowball/libstemmer/stem_UTF_8_porter.c 717 1 0.139275766016713 postgresql C postgresql-8.4.2/src/backend/snowball/libstemmer/stem_ISO_8859_1_finnish.c 714 1 0.13986013986014 postgresql C postgresql-8.4.2/src/backend/snowball/libstemmer/stem_ISO_8859_1_porter.c 711 1 0.140449438202247 postgresql C postgresql-8.4.2/src/backend/snowball/libstemmer/stem_KOI8_R_russian.c 660 1 0.151285930408472 postgresql C postgresql-8.4.2/src/backend/snowball/libstemmer/stem_UTF_8_russian.c 654 1 0.152671755725191 python C Python-2.6.4/Mac/Modules/qt/_Qtmodule.c 26705 42 0.157026956294164 python C Python-2.6.4/Mac/Modules/icn/_Icnmodule.c 1521 3 0.196850393700787 mysql C mysql-5.1.42/strings/ctype-extra.c 8348 17 0.203227734608488 python C Python-2.6.4/Python/Python-ast.c 5910 17 0.286823013328834 python C Python-2.6.4/Mac/Modules/menu/_Menumodule.c 3263 10 0.305530094714329 postgresql C postgresql-8.4.2/src/backend/snowball/libstemmer/stem_UTF_8_dutch.c 596 2 0.334448160535117 postgresql C postgresql-8.4.2/src/backend/snowball/libstemmer/stem_ISO_8859_1_dutch.c 586 2 0.340136054421769 perl C perl-5.10.0/x2p/a2p.c 2916 10 0.341763499658236 python C Python-2.6.4/Mac/Modules/qd/_Qdmodule.c 6694 24 0.357249181303959 python C Python-2.6.4/Mac/Modules/win/_Winmodule.c 3056 11 0.358656667753505 postgresql C postgresql-8.4.2/src/backend/snowball/libstemmer/stem_UTF_8_german.c 476 2 0.418410041841004 postgresql C postgresql-8.4.2/src/backend/snowball/libstemmer/stem_ISO_8859_1_german.c 470 2 0.423728813559322 perl C perl-5.10.0/x2p/walk.c 2024 10 0.491642084562439 python C Python-2.6.4/Mac/Modules/ctl/_Ctlmodule.c 5442 28 0.511882998171846 python C Python-2.6.4/Mac/Modules/ae/_AEmodule.c 1347 7 0.51698670605613 python C Python-2.6.4/Mac/Modules/app/_Appmodule.c 1712 9 0.52295177222545 mysql C mysql-5.1.42/strings/ctype-euc_kr.c 8691 49 0.560640732265446 mysql C mysql-5.1.42/storage/archive/archive_reader.c 348 2 0.571428571428571 python C Python-2.6.4/Mac/Modules/evt/_Evtmodule.c 504 3 0.591715976331361 python C Python-2.6.4/Modules/expat/xmlrole.c 1250 8 0.635930047694754 postgresql C postgresql-8.4.2/src/backend/snowball/libstemmer/stem_UTF_8_danish.c 312 2 0.636942675159236 mysql C mysql-5.1.42/strings/ctype-gbk.c 9946 64 0.639360639360639 postgresql C postgresql-8.4.2/src/backend/snowball/libstemmer/stem_ISO_8859_1_danish.c 310 2 0.641025641025641 mysql C mysql-5.1.42/strings/ctype-gb2312.c 5735 40 0.692640692640693 python C Python-2.6.4/Mac/Modules/res/_Resmodule.c 1621 12 0.734843845682792 python C Python-2.6.4/Mac/Modules/drag/_Dragmodule.c 1046 8 0.759013282732448 postgresql C postgresql-8.4.2/contrib/hstore/hstore_op.c 522 4 0.760456273764259 python C Python-2.6.4/Mac/Modules/list/_Listmodule.c 1022 8 0.776699029126214 python C Python-2.6.4/Mac/Modules/te/_TEmodule.c 1198 10 0.827814569536424 python C Python-2.6.4/Mac/Modules/cg/_CGmodule.c 1190 10 0.833333333333333 postgresql C postgresql-8.4.2/contrib/hstore/hstore_io.c 451 4 0.879120879120879 postgresql C postgresql-8.4.2/src/interfaces/ecpg/preproc/preproc.c 36905 330 0.886262924667651 python C Python-2.6.4/Modules/clmodule.c 2379 23 0.957535387177352 python C Python-2.6.4/Mac/Modules/folder/_Foldermodule.c 306 3 0.970873786407767
Какие десять самых длинных файлов (на основе строк кода), не имеют ни одного комментария вообще? �?сключая заголовок и YAML файлы.
> sqlite3 code.db 'select project, file, nCode from t where nComment = 0 and language not in ("C/C++ Header", "YAML") order by nCode desc limit 10;' | sqlite_formatter
Project File nCode
_______ _____________________________________________________ _____
python Python-2.6.4/PC/os2emx/python26.def 1188
python Python-2.6.4/Lib/test/cjkencodings_test.py 1019
python Python-2.6.4/Tools/msi/schema.py 920
python Python-2.6.4/Lib/msilib/schema.py 920
perl perl-5.10.0/symbian/config.sh 810
perl perl-5.10.0/uconfig.sh 771
python Python-2.6.4/Tools/pybench/Lookups.py 700
mysql mysql-5.1.42/scripts/mysql_fix_privilege_tables_sql.c 658
python Python-2.6.4/Tools/pybench/Numbers.py 637
python Python-2.6.4/Tools/pybench/Arithmetic.py 596
Какие языки наиболее популярные (в плане строк кода) в каждом проекте?
> sqlite3 code.db 'select project, language, sum(nCode) as SumCode from t group by project,language order by project,SumCode desc;' | sqlite_formatter Project Language SumCode __________ __________________ _______ mysql C++ 521041 mysql C 393602 mysql C/C++ Header 142779 mysql Bourne Shell 74525 mysql Perl 22703 mysql m4 10497 mysql make 4447 mysql XML 4107 mysql SQL 3433 mysql Assembly 1304 mysql yacc 1048 mysql lex 879 mysql Teamcenter def 701 mysql Javascript 427 mysql Pascal 377 mysql HTML 250 mysql Bourne Again Shell 48 mysql DOS Batch 36 perl Perl 292281 perl C 140483 perl C/C++ Header 44042 perl Bourne Shell 36882 perl Lisp 7515 perl make 2044 perl C++ 2000 perl XML 1972 perl yacc 1549 perl YAML 489 perl DOS Batch 322 perl HTML 98 postgresql C 563865 postgresql C/C++ Header 40990 postgresql Bourne Shell 28486 postgresql SQL 25862 postgresql yacc 22825 postgresql Perl 4894 postgresql lex 3638 postgresql make 3453 postgresql m4 1431 postgresql Teamcenter def 1104 postgresql HTML 410 postgresql DOS Batch 188 postgresql XSLT 111 postgresql Assembly 105 postgresql D 65 postgresql CSS 44 postgresql sed 15 postgresql Python 12 python Python 365716 python C 332551 python C/C++ Header 58234 python Bourne Shell 44626 python Assembly 9755 python m4 7124 python Lisp 2933 python HTML 2912 python make 2785 python Teamcenter def 2075 python Objective C 635 python DOS Batch 424 python CSS 308 python vim script 105 python XML 62 python Expect 60 python NAnt scripts 30 python Visual Basic 12 sqlite C 68944 sqlite Bourne Shell 25849 sqlite m4 6557 sqlite C/C++ Header 1077 sqlite make 13
Третье поколения факторов языкового масштабирования
Cloc версии до 1.50 по умолчанию вычисляется, за предоставленные входов, грубая оценка того, сколько строк кода будет нужно написать тот же код в гипотетическом языке третьего поколения компьютера. Для получения этого вывода один теперь должны использовать переключатель --3.
Масштабные коэффициенты были получены от версии языка соотношениях зацеплением перечисленных на веб-сайте Mayes Consulting, http://softwareestimator.com/IndustryData2.htm 2006 года с использованием этого уравнения:
Cloc масштабный коэффициент для языка X = 3-го поколения умолчанию коэффициент финансовой зависимости / язык X соотношения собственных и заемных
например,
Cloc масштабный фактор 3-го поколения для DOS Batch = 80/128 = 0,625
Самый большой недостаток этого подхода заключается в том, что для передач отношения определены для логических строк исходного кода не физические линии (который Cloc отсчетов). Значения в Cloc в "scale" и "3rd gen. equiv." колонки должны быть приняты с большим недоверием.
Ограничения
Определение комментарии в исходном коде сложнее, чем можно было бы ожидать. Многие языки потребуется полный парсер считаться правильно. Cloc не пытайтесь разобрать любой из языков он стремится рассчитывать, и поэтому является несовершенным инструментом. Ниже приведены известные проблемы:
1. Строки, содержащие как исходный код и комментарии считаются строк кода.
2. Маркеры комментариев в строках или документах-здесь рассматриваются как фактические маркеры комментариев, а не строчных литер. Например следующие строки кода C
printf(" /* ");
for (i = 0; i < 100; i++) {
a += i;
}
printf(" */ ");
по всей видимости, Cloc как две линии C кода (линии с черным текстом) и трех линий комментарии (линии, которые имеют только красный текст - линии с черной и красной текста рассматриваются как код).
3. длинные комментарии Lua, не признаются.
Как заказать поддержку для дополнительных языков?
Если Cloc не признает язык в подсчете которого вы заинтересованы, разместите следующую информацию в Feature Request на SourceForge странице Cloc:
1. Расширения, связанные с языком. Если язык не полагается на расширения файлов, а вместо этого работает с фиксированными именами файлов или с #! стилем программных вызовов, объясните, что это так.
2. Описание того, как комментарии определены.
3. Ссылки на пример кода.
Автор
Al Danial 
Благодарности
Wolfram Rösler обеспечил большинство примеров кода в наборе тестов. Эти примеры пришли из его Hello World Collection.
Ismet Kursunoglu нашел ошибки с MUMPS счетчиком и обеспечил доступ к компьютеру с большим телом кода MUMPS, чтобы протестировать Cloc.
Tod Huggins дал полезные советы для фильтров Visual Basic.
Антон Демичев нашел изъян с JSP счетчиком в Cloc v0.76 и написал XML выводящий генератор опции --xml.
Reuben Thomas отметил, что �?СО С99 позволяет // как маркера комментария, предоставил код для опций --no3 и --stdin-name, посчитал язык m4, и предложил несколько усовершенствований пользовательского интерфейса.
Michael Bello предоставил код для опций --opt-match-f, --opt-not-match-f, --opt-match-d и --opt-not-match-d.
Mahboob Hussain вдохновил на опции --original-dir и --skip-uniqueness, нашел ошибку в логике обнаружения дубликатов файлов и улучшил фильтр JSP.
Randy Sharo обнаружил и исправил неинициализированную переменной ошибку для shell скриптов, имеющих только одну строку.
Steven Baker обнаружил и исправил проблему с генератором вывода YAML.
Greg Toth предоставил код для улучшения обнаружения пустой строки в COBOL.
Joel Oliveira предоставил код, позволяющий --exclude-list-file управлять исключениями имен каталогов.
Blazej Kroll предоставил код производящий XSLT-файл, cloc-diff.xsl, при формировании внешнего XML для опции --diff.
Денис Силаков усовершенствовал код, который генерирует cloc.xsl когда используются опции --by-file и --by-file-by-lang и предоставил XSL файл, который работает с выходом --diff.
Andy (awalshe@sf.net) предоставил код для исправления некоторых ошибок: правильный вывод из --counted, так, что только те файлы, которые используются при подсчете кода появляются и эти результаты показанные языком скорее чем имя файла; позволяют вывод --diff из нескольких запусков быть просуммированными вместе с --sum-reports.
Jari Aalto создал первоначальный вариант cloc.1.pod и поддерживает пакет Debian для Cloc.
Mikkel Christiansen (mikkels@gmail.com) предоставил определения счетчика для Clojure и ClojureScript.
Erik Gooven Arellano Casillas предоставил обновление для MXML счетчика для распознавания комментариев Actionscript.
Gianluca Casati создал cloc CPAN package.
Ryan Lindeman реализовал функцию --by-percent.
Kent C. Dodds, @kentcdodds, создал и поддерживает npm пакет для cloc.
Развитие cloc частично финансируется Northrop Grumman Corporation.
Авторское право
Copyright (c) 2006-2015, 
Лицензия
Эта программа является бесплатным программным обеспечением; вы можете распространять ее и/или изменять ее в соответствии с условиями GNU General Public License, опубликованной Free Software Foundation; или версии 2 Лицензии, либо (по вашему выбору) любой более поздней версии.