Rust-Tokei v12.1.2: tokei — counts the lines of code

Tokei (時計)

Mean Bean CI crates.io Help Wanted Lines Of Code Documentation

Tokei is a program that displays statistics about your code. Tokei will show the number of files, total lines within those files and code, comments, and blanks grouped by language.

Translations

Example

-------------------------------------------------------------------------------
 Language            Files        Lines         Code     Comments       Blanks
-------------------------------------------------------------------------------
 BASH                    4           49           30           10            9
 JSON                    1         1214         1214            0            0
 Markdown                4         1236         1236            0            0
 Rust                   19         3049         2224          431          394
 Shell                   1           49           38            1           10
 TOML                    1           79           68            0           11
-------------------------------------------------------------------------------
 Total                  30         5676         4810          442          424
-------------------------------------------------------------------------------

API Documentation

Table of Contents

Features

  • Tokei is very fast, check out our latest release to see how Tokei's speed compares to others.

  • Tokei is accurate, Tokei correctly handles multi line comments, nested comments, and not counting comments that are in strings. Providing an accurate code statistics.

  • Tokei has huge range of languages, supporting over 150 languages, and their various extensions.

  • Tokei can output in multiple formats(CBOR, JSON, TOML, YAML) allowing Tokei's output to be easily stored, and reused. These can also be reused in tokei combining a previous run's statistics with another set.

  • Tokei is available on Mac, Linux, and Windows. See installation instructions for how to get Tokei on your platform.

  • Tokei is also a library allowing you to easily integrate it with other projects.

Installation

Package Managers

# Arch Linux
pacman -S tokei
# Cargo
cargo install tokei
# Conda
conda install -c conda-forge tokei
# Fedora
sudo dnf install tokei
# FreeBSD
pkg install tokei
# MacOS (Homebrew)
brew install tokei
# MacOS (MacPorts)
sudo port selfupdate
sudo port install tokei
# Nix/NixOS
nix-env -i tokei
# OpenSUSE
sudo zypper install tokei

Manual

Downloading

You can download prebuilt binaries in the releases section.

Building

You can also build and install from source (requires the latest stable Rust compiler.)

cargo install --git https://github.com/XAMPPRocky/tokei.git

Configuration

Tokei has a configuration file that allows you to change default behaviour. The file can be named tokei.toml or .tokeirc. Currently tokei looks for this file in three different places. The current directory,your home directory, and your configuration directory.

How to use Tokei

Basic usage

This is the basic way to use tokei. Which will report on the code in ./foo and all subfolders.

$ tokei ./foo

Multiple folders

To have tokei report on multiple folders in the same call simply add a comma, or a space followed by another path.

$ tokei ./foo ./bar ./baz
$ tokei ./foo, ./bar, ./baz

Excluding folders

Tokei will respect all .gitignore and .ignore files, and you can use the --exclude option to exclude any additional files. The --exclude flag has the same semantics as .gitignore.

$ tokei ./foo --exclude *.rs

Sorting output

By default tokei sorts alphabetically by language name, however using --sort tokei can also sort by any of the columns.

blanks, code, comments, lines

$ tokei ./foo --sort code

Outputting file statistics

By default tokei only outputs the total of the languages, and using --files flag tokei can also output individual file statistics.

$ tokei ./foo --files

Outputting into different formats

Tokei normally outputs into a nice human readable format designed for terminals. There is also using the --output option various other formats that are more useful for bringing the data into another program.

Note: This version of tokei was compiled without any serialization formats, to enable serialization, reinstall tokei with the features flag.

  ALL:
  cargo install tokei --features all

  JSON:
  cargo install tokei --features json

  CBOR:
  cargo install tokei --features cbor

  YAML:
  cargo install tokei --features yaml

  TOML:
  cargo install tokei --features toml

Currently supported formats

  • JSON --output json
  • YAML --output yaml
  • TOML --output toml
  • CBOR --output cbor
$ tokei ./foo --output json

Reading in stored formats

Tokei can also take in the outputted formats added in the previous results to it's current run. Tokei can take either a path to a file, the format passed in as a value to the option, or from stdin.

$ tokei ./foo --input ./stats.json

Options

USAGE:
    tokei [FLAGS] [OPTIONS] [--] [input]...

FLAGS:
    -f, --files               Will print out statistics on individual files.
    -h, --help                Prints help information
        --hidden              Count hidden files.
    -l, --languages           Prints out supported languages and their extensions.
        --no-ignore           Don't respect ignore files.
        --no-ignore-parent    Don't respect ignore files in parent directories.
        --no-ignore-vcs       Don't respect VCS ignore files.
    -V, --version             Prints version information
    -v, --verbose             Set log output level:
                                          1: to show unknown file extensions,
                                          2: reserved for future debugging,
                                          3: enable file level trace. Not recommended on multiple files

OPTIONS:
    -c, --columns <columns>       Sets a strict column width of the output, only available for terminal output.
    -e, --exclude <exclude>...    Ignore all files & directories containing the word.
    -i, --input <file_input>      Gives statistics from a previous tokei run. Can be given a file path, or "stdin" to
                                  read from stdin.
    -o, --output <output>         Outputs Tokei in a specific format. Compile with additional features for more format
                                  support. [possible values: cbor, json, yaml]
    -s, --sort <sort>             Sort languages based on column [possible values: files, lines, blanks, code, comments]
    -t, --type <types>            Filters output by language type, seperated by a comma. i.e. -t=Rust,Markdown

ARGS:
    <input>...    The input file(s)/directory(ies) to be counted.

Badges

Tokei has support for badges. For example .

[![](https://tokei.rs/b1/github/XAMPPRocky/tokei)](https://github.com/XAMPPRocky/tokei).

Tokei's URL scheme is as follows.

https://tokei.rs/b1/{host: values: github|gitlab}/{Repo Owner eg: XAMPPRocky}/{Repo name eg: tokei}

By default the badge will show the repo's LoC(Lines of Code), you can also specify for it to show a different category, by using the ?category= query string. It can be either code, blanks, files, lines, comments, Example show total lines:

[![](https://tokei.rs/b1/github/XAMPPRocky/tokei?category=lines)](https://github.com/XAMPPRocky/tokei).

The server code hosted on tokei.rs is in XAMPPRocky/tokei_rs

Plugins

Thanks to contributors tokei is now available as a plugin for some text editors.

Supported Languages

If there is a language that you would to add to tokei feel free to make a pull request. Languages are defined in languages.json, and you can read how to add and test your language in our CONTRIBUTING.md.

Abap
ActionScript
Ada
Agda
Alex
Alloy
Asn1
Asp
AspNet
Assembly
AssemblyGAS
Autoconf
AutoHotKey
Automake
Bash
Batch
BrightScript
C
Cabal
Cassius
Ceylon
CHeader
Clojure
ClojureC
ClojureScript
CMake
Cobol
CoffeeScript
Cogent
ColdFusion
ColdFusionScript
Coq
Cpp
CppHeader
Crystal
CSharp
CShell
Css
D
Dart
DeviceTree
Dhall
Dockerfile
DotNetResource
DreamMaker
Dust
Edn
Elisp
Elixir
Elm
Elvish
EmacsDevEnv
Emojicode
Erlang
FEN
Fish
FlatBuffers
Forth
FortranLegacy
FortranModern
FreeMarker
FSharp
Fstar
GDB
GdScript
Gherkin
Glsl
Go
Graphql
Groovy
Hamlet
Handlebars
Happy
Haskell
Haxe
Hcl
Hex
Hlsl
HolyC
Html
Idris
Ini
IntelHex
Isabelle
Jai
Java
JavaScript
Json
Jsx
Julia
Julius
KakouneScript
Kotlin
Lean
Less
LinkerScript
Liquid
Lisp
LLVM
Logtalk
Lua
Lucius
Madlang
Makefile
Markdown
Meson
Mint
ModuleDef
MoonScript
MsBuild
Mustache
Nim
Nix
NotQuitePerl
ObjectiveC
ObjectiveCpp
OCaml
Odin
Org
Oz
Pascal
Perl
Perl6
Pest
Php
Polly
Pony
PostCss
PowerShell
Processing
Prolog
Protobuf
PSL
PureScript
Python
Qcl
Qml
R
Racket
Rakefile
Razor
Renpy
ReStructuredText
RON
RPMSpecfile
Ruby
RubyHtml
Rust
Sass
Scala
Scheme
Scons
Sh
Sml
Solidity
SpecmanE
Spice
Sql
SRecode
Stratego
Svelte
Svg
Swift
Swig
SystemVerilog
Tcl
Tex
Text
Thrift
Toml
Tsx
Twig
TypeScript
UnrealDeveloperMarkdown
UnrealPlugin
UnrealProject
UnrealScript
UnrealShader
UnrealShaderHeader
UrWeb
UrWebProject
Vala
VB6
VBScript
Velocity
Verilog
VerilogArgsFile
Vhdl
VimScript
VisualBasic
VisualStudioProject
VisualStudioSolution
Vue
WebAssembly
Wolfram
Xaml
XcodeConfig
Xml
XSL
Xtend
Yaml
Zig
Zsh

Common issues

Tokei says I have a lot of D code, but I know there is no D code!

This is likely due to gcc generating .d files. Until the D people decide on a different file extension, you can always exclude .d files using the -e --exclude flag like so

$ tokei . -e *.d

Canonical Source

The canonical source of this repo is hosted on GitHub. If you have a GitHub account, please make your issues, and pull requests there.

Copyright and License

(C) Copyright 2015 by XAMPPRocky and contributors

See the graph for a full list of contributors.

Tokei is distributed under the terms of both the MIT license and the Apache License (Version 2.0).

See LICENCE-APACHE, LICENCE-MIT for more information.

Comments

  • language support: add ksh
    language support: add ksh

    Dec 14, 2021

    I see Sh, Bash, and Zsh but no Ksh please add it

    Reply
  • Bump serde from 1.0.128 to 1.0.132
    Bump serde from 1.0.128 to 1.0.132

    Dec 16, 2021

    Bumps serde from 1.0.128 to 1.0.132.

    Release notes

    Sourced from serde's releases.

    v1.0.132

    • Enable Serialize and Deserialize impls for std::sync::atomic::{AtomicI64, AtomicU64} on riscv64 arch (#2141, thanks @​Avimitin)

    v1.0.131

    • Avoid unused_results being triggered in generated code for adjacently tagged enum (#2116, thanks @​tyranron)

    v1.0.130

    • Provide MapAccess and SeqAccess impl for reference to a dynamically sized existing impl (#2081)

    v1.0.129

    • Support deserialization of remote structs that used packed repr (#2078, #2079, #2080)
    Commits

    Dependabot compatibility score

    Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting @dependabot rebase.


    Dependabot commands and options

    You can trigger Dependabot actions by commenting on this PR:

    • @dependabot rebase will rebase this PR
    • @dependabot recreate will recreate this PR, overwriting any edits that have been made to it
    • @dependabot merge will merge this PR after your CI passes on it
    • @dependabot squash and merge will squash and merge this PR after your CI passes on it
    • @dependabot cancel merge will cancel a previously requested merge and block automerging
    • @dependabot reopen will reopen this PR if it is closed
    • @dependabot close will close this PR and stop Dependabot recreating it. You can achieve the same result by closing it manually
    • @dependabot ignore this major version will close this PR and stop Dependabot creating any more for this major version (unless you reopen the PR or upgrade to it yourself)
    • @dependabot ignore this minor version will close this PR and stop Dependabot creating any more for this minor version (unless you reopen the PR or upgrade to it yourself)
    • @dependabot ignore this dependency will close this PR and stop Dependabot creating any more for this dependency (unless you reopen the PR or upgrade to it yourself)
    dependencies 
    Reply
  • Add basic Haml support
    Add basic Haml support

    Dec 28, 2021

    As seen in https://github.com/XAMPPRocky/tokei/issues/587 and https://github.com/XAMPPRocky/tokei/pull/597, Haml uses a unique syntax that is hard to integrate into tokei. Though it is better to have basic support than nothing.

    Alternative proposal: https://github.com/XAMPPRocky/tokei/pull/870

    Reply
  • Add Haml support with indented comments and embeddings
    Add Haml support with indented comments and embeddings

    Dec 29, 2021

    This is an alternative proposal to https://github.com/XAMPPRocky/tokei/pull/869.

    This PR adds support for Haml with indented comments and embeddings like:

      -# Embeddings
      :javascript
        // This is JavaScript code:
        console.log("Hello!");
    
      -# Comments
      /
        %p
          This is emitted in an HTML comment.
    

    Compared to https://github.com/XAMPPRocky/tokei/pull/869 this is more feature-complete but it makes the Rust implementation more complex. That is why I filed it as a separate proposal.

    Known problems:

    • Trailing empty lines in embeddings are entirely dropped from counting.
    • Trailing empty lines in indented comments are counted as comments, not blanks.
    Reply
  • Glob path with * as input
    Glob path with * as input

    Jan 1, 2022

    Hello, I was comparing features between https://github.com/XAMPPRocky/tokei/ and https://github.com/AlDanial/cloc I find they have minor count differences in the results but tokei seems to be much faster and works great, so I like it better. But there is one difference in functionality that cloc has and is very important for my use case, maybe for others as well.

    Directory structure example:

    \Project\Content
    ├───Name1
    │   ├───Code
    │   │   └───ClassDefs
    │   └───Presets
    │       ├───Preset
    │       ├───Other
    │       └───Templates
    ├───Name2
    │   ├───Code
    │   ├───Presets
    │   │   ├───Config
    │   │   └───Templates
    │   └───etc
    *
    

    In cloc you can count only the code in all sub-directories that have the folder Code in the end path:

    cloc Project/Content/*/Code
    

    This doesn't seem to be possible with tokei at the moment or I have no idea how to achieve it. Currently you have to go and list by hand every dir or achieve it by additional scripting which is not ideal.

    Note: Part of my real problem is that all files in the other sub-directories like Presets, etc. are with source file extensions e.g., ".lua" in my case but they actually don't contain any actual code logic, so I want to filter only the results from the Code dirs.

    Reply
  • Clap v3 + clippy fixes
    Clap v3 + clippy fixes

    Jan 1, 2022

    Upgrades to clap version 3, this one uses the builder method, although I feel the derive version may be better suited here. Additionally, it fixes several lints reported by clippy.

    I ran cargo test and it passed successfully, is there anything else that should be done?

    Reply
  • Fluent ftl files, improperly recognized as FreeMarker files
    Fluent ftl files, improperly recognized as FreeMarker files

    Jan 6, 2022

    https://projectfluent.org/fluent/guide/functions.html

    Example file - https://github.com/qarmin/czkawka/blob/master/i18n/en/czkawka_gui.ftl

    Reply
  • Flatpak / Snap package
    Flatpak / Snap package

    Jan 15, 2022

    Thank you so much for tokei! :raised_hands: It would be great if it would be available via platform independent package managers as well (i.e. Flatpak and/or Snap).

    Reply
  • 🐛 Problem with multiple language per file support
    🐛 Problem with multiple language per file support

    Jan 19, 2022

    Hi, when using tokei, file that include multiple language are not counted in the total. I'm not sure if this is a bug or it has been intended that way.

    Here is a vue project I work on, only 124 lines are counted for the vue part, instead of the 1969 ones. This is the same for markdown, actually,

    25 + 529 + 389 + 56 + 33 + 206 + 124 = 1362 Expected result (line section): 3209

    ===============================================================================
     Language            Files        Lines         Code     Comments       Blanks
    ===============================================================================
     HTML                    2           25           23            1            1
     JavaScript             10          529          508            0           21
     PHP                     8          389          221           98           70
     Shell                   4           56           41            1           14
     SVG                     7           33           33            0            0
    -------------------------------------------------------------------------------
     Markdown                3          206            0          160           46
     |- INI                  1            2            0            2            0
     (Total)                            208            0          162           46
    -------------------------------------------------------------------------------
     Vue                    16          124           94            0           30
     |- CSS                 15          822          699            0          123
     |- HTML                16          329          307            0           22
     |- JavaScript          16          694          636            1           57
     (Total)                           1969         1736            1          232
    ===============================================================================
     Total                  50         1362          920          260          182
    ===============================================================================
    
    Reply
  • [Request] badge support for gitlab group projects
    [Request] badge support for gitlab group projects

    Jan 20, 2022

    The badge URL scheme doesn't work for projects in GitLab groups.

    Example: https://gitlab.com/supersaiyansubtlety-group/minecraft-mods/sturdy_carts

    I tried:

    • https://tokei.rs/b1/gitlab/supersaiyansubtlety-group/minecraft-mods/sturdy_carts?category=code
    • https://tokei.rs/b1/gitlab/supersaiyansubtlety/sturdy_carts?category=code
    Reply
  • Add functionality to lines of code
    Add functionality to lines of code

    Sep 22, 2015

    Add capability to report both physical lines of code and logical lines of code

    Reply
  • Unrecognized/unsupported filetypes
    Unrecognized/unsupported filetypes

    Mar 24, 2018

    If a file don't have either an extension or a shebang, tokei should count it as plain text. If a file has an extension or a shebang, but it is not known by tokei, it should count it as Unsupported, and use the same rules as used with plain text (every line is code).

    Reply
  • Update existing languages with their String litreals.
    Update existing languages with their String litreals.

    Aug 21, 2016

    Now with the inclusion handling comments while in quotes, and out of them. All existing languages need to be updated with their string type as currently the default is (", ") which obviously doesn't apply to all languages. All that is needed to go to src/lib/language/languages.rs and use the set_quotes() method.

    • [ ] ActionScript
    • [ ] Ada
    • [x] Assembly
    • [ ] Autoconf
    • [x] BASH
    • [x] Batch
    • [x] C
    • [x] C Header
    • [x] Clojure
    • [x] CoffeeScript
    • [x] ColdFusion
    • [x] ColdFusion CFScript
    • [ ] Coq
    • [x] C++
    • [x] C++ Header
    • [ ] C#
    • [ ] C Shell
    • [x] CSS
    • [ ] D
    • [x] Dart
    • [ ] Device Tree
    • [ ] Erlang
    • [ ] Forth
    • [ ] FORTRAN Legacy
    • [ ] FORTRAN Modern
    • [ ] Go
    • [ ] Handlebars
    • [x] Haskell
    • [x] HTML
    • [x] Idris
    • [ ] Isabelle
    • [x] JAI
    • [x] Java
    • [x] JavaScript
    • [x] Julia
    • [x] JSON
    • [ ] JSX
    • [x] Kotlin
    • [ ] LESS
    • [ ] LD Script
    • [ ] LISP
    • [ ] Lua
    • [ ] Makefile
    • [x] Markdown
    • [ ] Mustache
    • [ ] Nim
    • [ ] Objective C
    • [ ] Objective C++
    • [ ] OCaml
    • [ ] Oz
    • [ ] Pascal
    • [ ] Perl
    • [ ] Polly
    • [x] PHP
    • [ ] Protocol Buffers
    • [ ] Prolog
    • [ ] Python
    • [ ] QCL
    • [ ] R
    • [ ] Ruby
    • [ ] Ruby HTML
    • [x] Rust
    • [ ] Sass
    • [ ] Scala
    • [ ] Standard ML
    • [ ] SQL
    • [ ] Swift
    • [ ] TeX
    • [x] Plain Text
    • [ ] TOML
    • [ ] TypeScript
    • [ ] Vim Script
    • [ ] Unreal Script
    • [ ] Wolfram
    • [ ] XML
    • [ ] YAML
    • [x] Zsh
    help wanted 
    Reply
  • Made a series of modifications to the languages comments:
    Made a series of modifications to the languages comments:

    Sep 10, 2016

    Clojure - Removed #
    Forth   - ( Comment) style comments need a space after the opening paren
    Haskell - Added multiline comment style {- Block comment -}
    Jai     - Has nested block comments
    Julia   - Has nested block comments
    Kotlin  - Has nested block comments
    Pascal  - Pascal should be multiline from { or (* to } or *)
    Perl    - Perl5 and earlier for multiline comments need =pod to =cut.
                Perl6 will be different but as it is not finished I'm not going
                to add it.
    Python  - Python can use """ or ''' for comments
    Swift   - Has nested block comments
    

    The is_fortran code was editted by rustfmt.

    Reply
  • Introduce `Bytes` to support processing of non-UTF-8 files.
    Introduce `Bytes` to support processing of non-UTF-8 files.

    Nov 10, 2018

    I was trying to use tokei to analyze older versions of the Linux kernel and noticed that it had issues with files containing comments which were encoded in iso-8859-1.

    Because DecodeReaderBytes wasn't actually configured to use any encoding it fell back to using UTF-8, unless a BOM was present. BOMs are exceedingly rare when dealing with code files in my experience, but it's still something that we should re-incorporate here before merging to maintain the old behavior. ~~My suggestion would be to perform an explicit check of the two first bytes in the stream~~ (see TODO).

    Unfortunately file encodings tend to be determined by build systems rather than the files themselves. But we can do other things like look for vim comments (e.g. # vim: set fileencoding=).

    While reading through the code, I noticed that the analysis performed by tokei didn't use a ton of string APIs, so I built the Bytes abstraction to handle all the cases that were needed to operate directly on top of a &[u8] slice.

    Any char inspection that we do now tries to decode a line using a method called utf8_chars_lossy(), which replaces any illegal utf-8 sequences with a replacement character U+FFFD.

    TODO

    • [x] Check BOM.
    • [x] Test for binary files
      • this was done before because DecodeReaderBytes always attempted to decode at least as UTF-8.
    Reply
  • add support for Meson
    add support for Meson

    Jan 3, 2018

    Fixes: https://github.com/Aaronepower/tokei/issues/168 Signed-off-by: Igor Gnatenko [email protected]

    Reply
  • 12.0.4 and master segfault on Windows, when built with optimizations.
    12.0.4 and master segfault on Windows, when built with optimizations.

    Aug 16, 2020

    I am installing and testing master and 12.0.4 using the current stable compiler 1.45.2. All tests are passing. But running tokei results in STATUS_ACCESS_VIOLATION (segfault). However the debug build seems to run fine (So it could be caused through optimizations?). When debugging it (release mode + debug info), it seems that it is crashing inside of the ignore crate, in the walk.rs file, in the visit method, on line 1293, where all the thread handles are joined. [link] This seems to be called by your utils/fs.rs, in the get_all_files method, on line 57, where you build and run the parallel file walkers. [link]

    This was an issue in the past: #543

    bug 
    Reply
  • Number of files tallying doesn't work
    Number of files tallying doesn't work

    Jun 6, 2016

    It seems piping output around doesn't update the file total, plus, only the file types from the final command are being tallied.

    ~$  tokei usercorn-unstable/
    -------------------------------------------------------------------------------
     Language            Files        Lines         Code     Comments       Blanks
    -------------------------------------------------------------------------------
     Go                    149         9163         7886          298          979
     Makefile                1           26           18            0            8
     Markdown                3          254          254            0            0
     Python                  2          154          125            2           27
     YAML                    1           20           17            0            3
    -------------------------------------------------------------------------------
     Total                 156         9617         8300          300         1017
    -------------------------------------------------------------------------------
    
    
    ~$  tokei go/src/github.com/
    -------------------------------------------------------------------------------
     Language            Files        Lines         Code     Comments       Blanks
    -------------------------------------------------------------------------------
     BASH                    1            8            6            1            1
     C Header                6         3435         2939          400           96
     Go                    170        29590        25755         1492         2343
     Markdown               13         1090         1090            0            0
     Python                  2          130          101            9           20
     YAML                    6           69           65            0            4
    -------------------------------------------------------------------------------
     Total                 198        34322        29956         1902         2464
    -------------------------------------------------------------------------------
    
    ~$  tokei -o json go/src/github.com/ | tokei -i stdin usercorn-unstable/
    -------------------------------------------------------------------------------
     Language            Files        Lines         Code     Comments       Blanks
    -------------------------------------------------------------------------------
     Go                    149        38753        33641         1790         3322
     Makefile                1           26           18            0            8
     Markdown                3         1344         1344            0            0
     Python                  2          284          226           11           47
     YAML                    1           89           82            0            7
    -------------------------------------------------------------------------------
     Total                 163        43939        38256         2202         3481
    -------------------------------------------------------------------------------
    
    Reply
  • Show Inaccuracy Warning on permission error
    Show Inaccuracy Warning on permission error

    Oct 1, 2018

    This PR roughly implements issue #165. I am sure there is room for some improvements on my code changes so feel free to comment on everything I changed. One thing I dislike that I did is this weird if let bundle I created to check for a permission error at one place: https://github.com/Veykril/tokei/blob/0c7e18d1b0b45832c40c3a991be4bd57111ff5e5/src/utils/fs.rs#L52-L61 I couldnt come up with a better way since the nested errors are boxed and box patterns arent stable yet.

    Example Output:

    C:\Workspace\Rust\tokei (error_output -> origin)                                                                       
    λ cargo run -- C:\Workspace\Rust\test                                                                                  
        Finished dev [unoptimized + debuginfo] target(s) in 0.18s                                                          
         Running `target\debug\tokei.exe C:\Workspace\Rust\test`                                                           
    ERROR 2018-10-01T16:28:56Z: tokei::utils::fs: Permission denied for reading C:\Workspace\Rust\test\Cargo.toml          
    Note: results can be inaccurate for languages marked with '(!)'                                                        
    -----------------------------------------------------------------------------------------------------------------------
     Language                                                    Files        Lines         Code     Comments       Blanks 
    -----------------------------------------------------------------------------------------------------------------------
     Markdown                                                        4         1380         1380            0            0 
     Rust                                                            1          123           99            1           23 
     Shell                                                           1           40           29            1           10 
     TOML (!)                                                        1           84           69            0           15 
     YAML                                                            1           80           60            8           12 
    -----------------------------------------------------------------------------------------------------------------------
     Total (!)                                                        8         1707         1637           10           60
    -----------------------------------------------------------------------------------------------------------------------
    
    Reply
  • tokei.rs: Badge Always Returns Processing
    tokei.rs: Badge Always Returns Processing

    Jun 17, 2021

    It seems to display failed while lines more than 10000? 图片

    Reply