Update dependencies, including tokei

15 files changed, 47 insertions, 527 deletions

diff --git a/crate_db/Cargo.toml b/crate_db/Cargo.toml
index 2fb4a87..a4c4a4b 100644
--- a/crate_db/Cargo.toml
+++ b/crate_db/Cargo.toml
@@ -18,5 +18,5 @@ rayon = "1.0.1"
 lazy_static = "1.0.0"
 chrono = "0.4.2"
 thread_local = "0.3.6"
-parking_lot = "0.7.1"
+parking_lot = "0.9"
 rake = { git = "https://github.com/kornelski/rake-rs" }
diff --git a/crate_files/src/tarball.rs b/crate_files/src/tarball.rs
index 96a6e3d..383c00b 100644
--- a/crate_files/src/tarball.rs
+++ b/crate_files/src/tarball.rs
@@ -11,6 +11,7 @@ use std::path::Path;
 use std::path::PathBuf;
 use tar::Archive;
 use udedokei;
+use udedokei::LanguageExt;
 
 enum ReadAs {
     Toml,
@@ -78,7 +79,7 @@ pub fn read_archive(archive: impl Read, prefix: &Path) -> Result<CrateFile> {
 
         match path_match {
             ReadAs::Lib => {
-                stats.add_to_stats(udedokei::Language::from_path("lib.rs").unwrap(), &data);
+                stats.add_to_stats(udedokei::from_path("lib.rs").unwrap(), &data);
                 if check_if_uses_nightly_features(&data) {
                     is_nightly = true;
                 }
@@ -150,5 +151,5 @@ fn is_source_code_file(path: &Path) -> Option<udedokei::Language> {
     } else {
         return None;
     }
-    udedokei::Language::from_path(path)
+    udedokei::from_path(path)
 }
diff --git a/crates_io_client b/crates_io_client
-Subproject 537e8ce0cb16a01b4043cdf9a82110c15f90fa5
+Subproject 32acb42d31753885a772d0d25cb4fd7c3c489d8
diff --git a/front_end/Cargo.toml b/front_end/Cargo.toml
index 90263ef..1243c7c 100644
--- a/front_end/Cargo.toml
+++ b/front_end/Cargo.toml
@@ -24,9 +24,9 @@ failure = "0.1.2"
 chrono = "0.4.2"
 semver = "0.9.0"
 semver-parser = "0.9.0"
-lab = "0.6.0"
+lab = "0.7"
 urlencoding = "1.0.0"
 regex = "1.0.0"
 locale = "0.2.2"
 url = "1.7.1"
-parking_lot = "0.7.1"
+parking_lot = "0.9"
diff --git a/front_end/src/crate_page.rs b/front_end/src/crate_page.rs
index b733896..048651d 100644
--- a/front_end/src/crate_page.rs
+++ b/front_end/src/crate_page.rs
@@ -28,6 +28,7 @@ use std::f64::consts::PI;
 use std::fmt::Display;
 use std::hash::Hash;
 use udedokei::{Language, Lines, Stats};
+use udedokei::LanguageExt;
 use url::Url;
 
 /// Data sources used in `crate_page.rs.html`
diff --git a/front_end/templates/crate_page.rs.html b/front_end/templates/crate_page.rs.html
index 8dc9671..e9991d3 100644
--- a/front_end/templates/crate_page.rs.html
+++ b/front_end/templates/crate_page.rs.html
@@ -10,6 +10,7 @@
 @use rich_crate::Include;
 @use rich_crate::Edition;
 @use std::ops::Div;
+@use udedokei::LanguageExt;
 
 @(url: &Urler, c: &CratePage)
 
diff --git a/kitchen_sink/Cargo.toml b/kitchen_sink/Cargo.toml
index 040eda4..c20c946 100644
--- a/kitchen_sink/Cargo.toml
+++ b/kitchen_sink/Cargo.toml
@@ -44,5 +44,5 @@ ctrlc = "3.1.1"
 flate2 = "1.0.6"
 string-interner = "0.7.0"
 fxhash = "0.2.1"
-parking_lot = "0.7.1"
+parking_lot = "0.9"
 
diff --git a/lazyonce b/lazyonce
-Subproject de196cd0e1b9bee137630dcf49a25f2eb0c7035
+Subproject 022be18cd09b3e149b6995eb34af9ac1ebc611a
diff --git a/reindex/Cargo.toml b/reindex/Cargo.toml
index 65720ff..41296b3 100644
--- a/reindex/Cargo.toml
+++ b/reindex/Cargo.toml
@@ -12,10 +12,10 @@ repo_url = { git = "https://gitlab.com/crates.rs/repo_url.git" }
 user_db = { path = "../user_db", version = "0.3" }
 failure = "0.1.1"
 rayon = "1.0.3"
-rand = "0.6"
+rand = "0.7"
 search_index = { path = "../search_index" }
 render_readme = { git = "https://gitlab.com/crates.rs/render_readme.git" }
 ranking = { path = "../ranking" }
 either = "1.5.0"
-parking_lot = "0.7.1"
+parking_lot = "0.9"
 udedokei = { path = "../udedokei" }
diff --git a/reindex/src/bin/reindex_crates.rs b/reindex/src/bin/reindex_crates.rs
index bf8ab72..189daa8 100644
--- a/reindex/src/bin/reindex_crates.rs
+++ b/reindex/src/bin/reindex_crates.rs
@@ -12,6 +12,7 @@ use search_index::*;
 use std::collections::HashSet;
 use std::sync::mpsc;
 use std::sync::Arc;
+use udedokei::LanguageExt;
 
 fn main() {
     let crates = Arc::new(match kitchen_sink::KitchenSink::new_default() {
diff --git a/render_readme b/render_readme
-Subproject e1aa4754908fe7e4a66e0b9557b58bf748ff7fd
+Subproject bb36743b5340cdeaf94b351272ac9c63e1241ee
diff --git a/search_index/Cargo.toml b/search_index/Cargo.toml
index cc93950..e27cccf 100644
--- a/search_index/Cargo.toml
+++ b/search_index/Cargo.toml
@@ -12,4 +12,4 @@ path = "src/lib_search_index.rs"
 tantivy = "0.10"
 kitchen_sink = { path = "../kitchen_sink", version = "0.7.0" }
 rayon = "1.0.3"
-rand = "0.6.1"
+rand = "0.7"
diff --git a/udedokei/Cargo.toml b/udedokei/Cargo.toml
index 8a3d2be..89f63d3 100644
--- a/udedokei/Cargo.toml
+++ b/udedokei/Cargo.toml
@@ -5,7 +5,7 @@ version = "0.1.0"
 authors = ["Kornel <kornel@geekhood.net>"]
 
 [dependencies]
-tokei = "8.0.1"
+tokei = "10.0.1"
 ignore = "0.4.3"
 serde = "1.0.76"
 serde_derive = "1.0.76"
diff --git a/udedokei/src/lib.rs b/udedokei/src/lib.rs
index 49030f2..3b0b36d 100644
--- a/udedokei/src/lib.rs
+++ b/udedokei/src/lib.rs
@@ -1,170 +1,11 @@
 use std::collections::HashMap;
+use std::path::PathBuf;
 use std::path::Path;
 
 use serde_derive::*;
 use tokei;
 
-use tokei::LanguageType as LT;
-
-#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash, Serialize, Deserialize)]
-pub enum Language {
-    Abap,
-    ActionScript,
-    Ada,
-    Agda,
-    Alex,
-    Asp,
-    AspNet,
-    Assembly,
-    AutoHotKey,
-    Autoconf,
-    Bash,
-    Batch,
-    BrightScript,
-    C,
-    CHeader,
-    CMake,
-    CSharp,
-    CShell,
-    Cabal,
-    Cassius,
-    Ceylon,
-    Clojure,
-    ClojureC,
-    ClojureScript,
-    Cobol,
-    CoffeeScript,
-    Cogent,
-    ColdFusion,
-    ColdFusionScript,
-    Coq,
-    Cpp,
-    CppHeader,
-    Crystal,
-    Css,
-    D,
-    Dart,
-    DeviceTree,
-    Dockerfile,
-    DreamMaker,
-    Edn,
-    Elisp,
-    Elixir,
-    Elm,
-    Elvish,
-    EmacsDevEnv,
-    Erlang,
-    FEN,
-    FSharp,
-    Fish,
-    Forth,
-    FortranLegacy,
-    FortranModern,
-    Fstar,
-    GdScript,
-    Glsl,
-    Go,
-    Groovy,
-    Hamlet,
-    Handlebars,
-    Happy,
-    Haskell,
-    Haxe,
-    Hcl,
-    Hex,
-    Html,
-    Idris,
-    IntelHex,
-    Isabelle,
-    Jai,
-    Java,
-    JavaScript,
-    Json,
-    Jsx,
-    Julia,
-    Julius,
-    KakouneScript,
-    Kotlin,
-    Lean,
-    Less,
-    LinkerScript,
-    Lisp,
-    Lua,
-    Lucius,
-    Madlang,
-    Makefile,
-    Markdown,
-    Meson,
-    Mint,
-    ModuleDef,
-    MsBuild,
-    Mustache,
-    Nim,
-    Nix,
-    OCaml,
-    ObjectiveC,
-    ObjectiveCpp,
-    Org,
-    Oz,
-    PSL,
-    Pascal,
-    Perl,
-    Php,
-    Polly,
-    Processing,
-    Prolog,
-    Protobuf,
-    PureScript,
-    Python,
-    Qcl,
-    Qml,
-    R,
-    Racket,
-    Rakefile,
-    Razor,
-    ReStructuredText,
-    Ruby,
-    RubyHtml,
-    Rust,
-    SRecode,
-    Sass,
-    Scala,
-    Scheme,
-    Scons,
-    Sh,
-    Sml,
-    SpecmanE,
-    Spice,
-    Sql,
-    Svg,
-    Swift,
-    SystemVerilog,
-    Tcl,
-    Tex,
-    Text,
-    Toml,
-    TypeScript,
-    UnrealScript,
-    UrWeb,
-    UrWebProject,
-    VB6,
-    VBScript,
-    Vala,
-    Verilog,
-    VerilogArgsFile,
-    Vhdl,
-    VimScript,
-    VisualBasic,
-    Vue,
-    Wolfram,
-    XSL,
-    Xaml,
-    Xml,
-    Xtend,
-    Yaml,
-    Zig,
-    Zsh,
-}
+pub use tokei::LanguageType as Language;
 
 #[derive(Debug, Clone, Default, Serialize, Deserialize)]
 pub struct Stats {
@@ -180,16 +21,25 @@ pub struct Lines {
 
 #[derive(Debug)]
 pub struct Collect {
-    dummy_dir_entry: ignore::DirEntry,
     stats: Stats,
 }
 
-impl Language {
-    pub fn name(&self) -> &str {
-        self.tokei_lang().name()
-    }
+pub trait LanguageExt {
+    fn is_code(&self) -> bool;
+    fn color(&self) -> &'static str;
+}
+
+pub fn from_path(path: impl AsRef<Path>) -> Option<Language> {
+    Language::from_path(path.as_ref(), &tokei::Config {
+        no_ignore: Some(true),
+        no_ignore_parent: Some(true),
+        treat_doc_strings_as_comments: Some(true),
+        ..Default::default()
+    })
+}
 
-    pub fn is_code(&self) -> bool {
+impl LanguageExt for Language {
+    fn is_code(&self) -> bool {
         match *self {
             Language::AutoHotKey |
             Language::Autoconf |
@@ -232,7 +82,7 @@ impl Language {
         }
     }
 
-    pub fn color(&self) -> &'static str {
+    fn color(&self) -> &'static str {
         match *self {
             Language::Abap => "#E8274B",
             Language::ActionScript => "#882B0F",
@@ -368,344 +218,11 @@ impl Language {
             _ => "#a5a3a0",
         }
     }
-
-    fn tokei_lang(self) -> LT {
-        match self {
-            Language::Abap => LT::Abap,
-            Language::ActionScript => LT::ActionScript,
-            Language::Ada => LT::Ada,
-            Language::Agda => LT::Agda,
-            Language::Alex => LT::Alex,
-            Language::Asp => LT::Asp,
-            Language::AspNet => LT::AspNet,
-            Language::Assembly => LT::Assembly,
-            Language::AutoHotKey => LT::AutoHotKey,
-            Language::Autoconf => LT::Autoconf,
-            Language::Bash => LT::Bash,
-            Language::Batch => LT::Batch,
-            Language::BrightScript => LT::BrightScript,
-            Language::C => LT::C,
-            Language::CHeader => LT::CHeader,
-            Language::CMake => LT::CMake,
-            Language::CSharp => LT::CSharp,
-            Language::CShell => LT::CShell,
-            Language::Cabal => LT::Cabal,
-            Language::Cassius => LT::Cassius,
-            Language::Ceylon => LT::Ceylon,
-            Language::Clojure => LT::Clojure,
-            Language::ClojureC => LT::ClojureC,
-            Language::ClojureScript => LT::ClojureScript,
-            Language::Cobol => LT::Cobol,
-            Language::CoffeeScript => LT::CoffeeScript,
-            Language::Cogent => LT::Cogent,
-            Language::ColdFusion => LT::ColdFusion,
-            Language::ColdFusionScript => LT::ColdFusionScript,
-            Language::Coq => LT::Coq,
-            Language::Cpp => LT::Cpp,
-            Language::CppHeader => LT::CppHeader,
-            Language::Crystal => LT::Crystal,
-            Language::Css => LT::Css,
-            Language::D => LT::D,
-            Language::Dart => LT::Dart,
-            Language::DeviceTree => LT::DeviceTree,
-            Language::Dockerfile => LT::Dockerfile,
-            Language::DreamMaker => LT::DreamMaker,
-            Language::Edn => LT::Edn,
-            Language::Elisp => LT::Elisp,
-            Language::Elixir => LT::Elixir,
-            Language::Elm => LT::Elm,
-            Language::Elvish => LT::Elvish,
-            Language::EmacsDevEnv => LT::EmacsDevEnv,
-            Language::Erlang => LT::Erlang,
-            Language::FEN => LT::FEN,
-            Language::FSharp => LT::FSharp,
-            Language::Fish => LT::Fish,
-            Language::Forth => LT::Forth,
-            Language::FortranLegacy => LT::FortranLegacy,
-            Language::FortranModern => LT::FortranModern,
-            Language::Fstar => LT::Fstar,
-            Language::GdScript => LT::GdScript,
-            Language::Glsl => LT::Glsl,
-            Language::Go => LT::Go,
-            Language::Groovy => LT::Groovy,
-            Language::Hamlet => LT::Hamlet,
-            Language::Handlebars => LT::Handlebars,
-            Language::Happy => LT::Happy,
-            Language::Haskell => LT::Haskell,
-            Language::Haxe => LT::Haxe,
-            Language::Hcl => LT::Hcl,
-            Language::Hex => LT::Hex,
-            Language::Html => LT::Html,
-            Language::Idris => LT::Idris,
-            Language::IntelHex => LT::IntelHex,
-            Language::Isabelle => LT::Isabelle,
-            Language::Jai => LT::Jai,
-            Language::Java => LT::Java,
-            Language::JavaScript => LT::JavaScript,
-            Language::Json => LT::Json,
-            Language::Jsx => LT::Jsx,
-            Language::Julia => LT::Julia,
-            Language::Julius => LT::Julius,
-            Language::KakouneScript => LT::KakouneScript,
-            Language::Kotlin => LT::Kotlin,
-            Language::Lean => LT::Lean,
-            Language::Less => LT::Less,
-            Language::LinkerScript => LT::LinkerScript,
-            Language::Lisp => LT::Lisp,
-            Language::Lua => LT::Lua,
-            Language::Lucius => LT::Lucius,
-            Language::Madlang => LT::Madlang,
-            Language::Makefile => LT::Makefile,
-            Language::Markdown => LT::Markdown,
-            Language::Meson => LT::Meson,
-            Language::Mint => LT::Mint,
-            Language::ModuleDef => LT::ModuleDef,
-            Language::MsBuild => LT::MsBuild,
-            Language::Mustache => LT::Mustache,
-            Language::Nim => LT::Nim,
-            Language::Nix => LT::Nix,
-            Language::OCaml => LT::OCaml,
-            Language::ObjectiveC => LT::ObjectiveC,
-            Language::ObjectiveCpp => LT::ObjectiveCpp,
-            Language::Org => LT::Org,
-            Language::Oz => LT::Oz,
-            Language::PSL => LT::PSL,
-            Language::Pascal => LT::Pascal,
-            Language::Perl => LT::Perl,
-            Language::Php => LT::Php,
-            Language::Polly => LT::Polly,
-            Language::Processing => LT::Processing,
-            Language::Prolog => LT::Prolog,
-            Language::Protobuf => LT::Protobuf,
-            Language::PureScript => LT::PureScript,
-            Language::Python => LT::Python,
-            Language::Qcl => LT::Qcl,
-            Language::Qml => LT::Qml,
-            Language::R => LT::R,
-            Language::Racket => LT::Racket,
-            Language::Rakefile => LT::Rakefile,
-            Language::Razor => LT::Razor,
-            Language::ReStructuredText => LT::ReStructuredText,
-            Language::Ruby => LT::Ruby,
-            Language::RubyHtml => LT::RubyHtml,
-            Language::Rust => LT::Rust,
-            Language::SRecode => LT::SRecode,
-            Language::Sass => LT::Sass,
-            Language::Scala => LT::Scala,
-            Language::Scheme => LT::Scheme,
-            Language::Scons => LT::Scons,
-            Language::Sh => LT::Sh,
-            Language::Sml => LT::Sml,
-            Language::SpecmanE => LT::SpecmanE,
-            Language::Spice => LT::Spice,
-            Language::Sql => LT::Sql,
-            Language::Svg => LT::Svg,
-            Language::Swift => LT::Swift,
-            Language::SystemVerilog => LT::SystemVerilog,
-            Language::Tcl => LT::Tcl,
-            Language::Tex => LT::Tex,
-            Language::Text => LT::Text,
-            Language::Toml => LT::Toml,
-            Language::TypeScript => LT::TypeScript,
-            Language::UnrealScript => LT::UnrealScript,
-            Language::UrWeb => LT::UrWeb,
-            Language::UrWebProject => LT::UrWebProject,
-            Language::VB6 => LT::VB6,
-            Language::VBScript => LT::VBScript,
-            Language::Vala => LT::Vala,
-            Language::Verilog => LT::Verilog,
-            Language::VerilogArgsFile => LT::VerilogArgsFile,
-            Language::Vhdl => LT::Vhdl,
-            Language::VimScript => LT::VimScript,
-            Language::VisualBasic => LT::VisualBasic,
-            Language::Vue => LT::Vue,
-            Language::Wolfram => LT::Wolfram,
-            Language::XSL => LT::XSL,
-            Language::Xaml => LT::Xaml,
-            Language::Xml => LT::Xml,
-            Language::Xtend => LT::Xtend,
-            Language::Yaml => LT::Yaml,
-            Language::Zig => LT::Zig,
-            Language::Zsh => LT::Zsh,
-        }
-    }
-
-    #[inline]
-    pub fn from_path(path: impl AsRef<Path>) -> Option<Self> {
-        LT::from_path(path.as_ref())
-        .map(|l| match l {
-            LT::Abap => Language::Abap,
-            LT::ActionScript => Language::ActionScript,
-            LT::Ada => Language::Ada,
-            LT::Agda => Language::Agda,
-            LT::Alex => Language::Alex,
-            LT::Asp => Language::Asp,
-            LT::AspNet => Language::AspNet,
-            LT::Assembly => Language::Assembly,
-            LT::AutoHotKey => Language::AutoHotKey,
-            LT::Autoconf => Language::Autoconf,
-            LT::Bash => Language::Bash,
-            LT::Batch => Language::Batch,
-            LT::BrightScript => Language::BrightScript,
-            LT::C => Language::C,
-            LT::CHeader => Language::CHeader,
-            LT::CMake => Language::CMake,
-            LT::CSharp => Language::CSharp,
-            LT::CShell => Language::CShell,
-            LT::Cabal => Language::Cabal,
-            LT::Cassius => Language::Cassius,
-            LT::Ceylon => Language::Ceylon,
-            LT::Clojure => Language::Clojure,
-            LT::ClojureC => Language::ClojureC,
-            LT::ClojureScript => Language::ClojureScript,
-            LT::Cobol => Language::Cobol,
-            LT::CoffeeScript => Language::CoffeeScript,
-            LT::Cogent => Language::Cogent,
-            LT::ColdFusion => Language::ColdFusion,
-            LT::ColdFusionScript => Language::ColdFusionScript,
-            LT::Coq => Language::Coq,
-            LT::Cpp => Language::Cpp,
-            LT::CppHeader => Language::CppHeader,
-            LT::Crystal => Language::Crystal,
-            LT::Css => Language::Css,
-            LT::D => Language::D,
-            LT::Dart => Language::Dart,
-            LT::DeviceTree => Language::DeviceTree,
-            LT::Dockerfile => Language::Dockerfile,
-            LT::DreamMaker => Language::DreamMaker,
-            LT::Edn => Language::Edn,
-            LT::Elisp => Language::Elisp,
-            LT::Elixir => Language::Elixir,
-            LT::Elm => Language::Elm,
-            LT::Elvish => Language::Elvish,
-            LT::EmacsDevEnv => Language::EmacsDevEnv,
-            LT::Erlang => Language::Erlang,
-            LT::FEN => Language::FEN,
-            LT::FSharp => Language::FSharp,
-            LT::Fish => Language::Fish,
-            LT::Forth => Language::Forth,
-            LT::FortranLegacy => Language::FortranLegacy,
-            LT::FortranModern => Language::FortranModern,
-            LT::Fstar => Language::Fstar,
-            LT::GdScript => Language::GdScript,
-            LT::Glsl => Language::Glsl,
-            LT::Go => Language::Go,
-            LT::Groovy => Language::Groovy,
-            LT::Hamlet => Language::Hamlet,
-            LT::Handlebars => Language::Handlebars,
-            LT::Happy => Language::Happy,
-            LT::Haskell => Language::Haskell,
-            LT::Haxe => Language::Haxe,
-            LT::Hcl => Language::Hcl,
-            LT::Hex => Language::Hex,
-            LT::Html => Language::Html,
-            LT::Idris => Language::Idris,
-            LT::IntelHex => Language::IntelHex,
-            LT::Isabelle => Language::Isabelle,
-            LT::Jai => Language::Jai,
-            LT::Java => Language::Java,
-            LT::JavaScript => Language::JavaScript,
-            LT::Json => Language::Json,
-            LT::Jsx => Language::Jsx,
-            LT::Julia => Language::Julia,
-            LT::Julius => Language::Julius,
-            LT::KakouneScript => Language::KakouneScript,
-            LT::Kotlin => Language::Kotlin,
-            LT::Lean => Language::Lean,
-            LT::Less => Language::Less,
-            LT::LinkerScript => Language::LinkerScript,
-            LT::Lisp => Language::Lisp,
-            LT::Lua => Language::Lua,
-            LT::Lucius => Language::Lucius,
-            LT::Madlang => Language::Madlang,
-            LT::Makefile => Language::Makefile,
-            LT::Markdown => Language::Markdown,
-            LT::Meson => Language::Meson,
-            LT::Mint => Language::Mint,
-            LT::ModuleDef => Language::ModuleDef,
-            LT::MsBuild => Language::MsBuild,
-            LT::Mustache => Language::Mustache,
-            LT::Nim => Language::Nim,
-            LT::Nix => Language::Nix,
-            LT::OCaml => Language::OCaml,
-            LT::ObjectiveC => Language::ObjectiveC,
-            LT::ObjectiveCpp => Language::ObjectiveCpp,
-            LT::Org => Language::Org,
-            LT::Oz => Language::Oz,
-            LT::PSL => Language::PSL,
-            LT::Pascal => Language::Pascal,
-            LT::Perl => Language::Perl,
-            LT::Php => Language::Php,
-            LT::Polly => Language::Polly,
-            LT::Processing => Language::Processing,
-            LT::Prolog => Language::Prolog,
-            LT::Protobuf => Language::Protobuf,
-            LT::PureScript => Language::PureScript,
-            LT::Python => Language::Python,
-            LT::Qcl => Language::Qcl,
-            LT::Qml => Language::Qml,
-            LT::R => Language::R,
-            LT::Racket => Language::Racket,
-            LT::Rakefile => Language::Rakefile,
-            LT::Razor => Language::Razor,
-            LT::ReStructuredText => Language::ReStructuredText,
-            LT::Ruby => Language::Ruby,
-            LT::RubyHtml => Language::RubyHtml,
-            LT::Rust => Language::Rust,
-            LT::SRecode => Language::SRecode,
-            LT::Sass => Language::Sass,
-            LT::Scala => Language::Scala,
-            LT::Scheme => Language::Scheme,
-            LT::Scons => Language::Scons,
-            LT::Sh => Language::Sh,
-            LT::Sml => Language::Sml,
-            LT::SpecmanE => Language::SpecmanE,
-            LT::Spice => Language::Spice,
-            LT::Sql => Language::Sql,
-            LT::Svg => Language::Svg,
-            LT::Swift => Language::Swift,
-            LT::SystemVerilog => Language::SystemVerilog,
-            LT::Tcl => Language::Tcl,
-            LT::Tex => Language::Tex,
-            LT::Text => Language::Text,
-            LT::Toml => Language::Toml,
-            LT::TypeScript => Language::TypeScript,
-            LT::UnrealScript => Language::UnrealScript,
-            LT::UrWeb => Language::UrWeb,
-            LT::UrWebProject => Language::UrWebProject,
-            LT::VB6 => Language::VB6,
-            LT::VBScript => Language::VBScript,
-            LT::Vala => Language::Vala,
-            LT::Verilog => Language::Verilog,
-            LT::VerilogArgsFile => Language::VerilogArgsFile,
-            LT::Vhdl => Language::Vhdl,
-            LT::VimScript => Language::VimScript,
-            LT::VisualBasic => Language::VisualBasic,
-            LT::Vue => Language::Vue,
-            LT::Wolfram => Language::Wolfram,
-            LT::XSL => Language::XSL,
-            LT::Xaml => Language::Xaml,
-            LT::Xml => Language::Xml,
-            LT::Xtend => Language::Xtend,
-            LT::Yaml => Language::Yaml,
-            LT::Zig => Language::Zig,
-            LT::Zsh => Language::Zsh,
-        })
-    }
 }
 
 impl Collect {
     pub fn new() -> Self {
-        // tokei wants DirEntry
-        let dummy_dir_entry = ignore::WalkBuilder::new("-")
-                            .parents(false).ignore(false)
-                            .git_global(false).git_ignore(false).git_exclude(false)
-                            .build()
-                            .next()
-                            .expect("tokei")
-                            .expect("tokei");
         Self {
-            dummy_dir_entry,
             stats: Stats::default(),
         }
     }
@@ -718,16 +235,15 @@ impl Collect {
         if lang == Language::Rust {
             self.rust_code_stats(file_content);
         }
-        match lang.tokei_lang().parse_from_str(self.dummy_dir_entry.clone(), file_content) {
-            Ok(res) => {
-                let stats = self.stats.langs.entry(lang).or_insert(Lines {comments:0, code:0});
-                stats.comments += res.comments as u32;
-                stats.code += res.code as u32;
-            },
-            Err(err) => {
-                eprintln!("warning: {} ", err);
-            },
-        }
+        let res = lang.parse_from_str(PathBuf::default(), file_content, &tokei::Config {
+            no_ignore: Some(true),
+            no_ignore_parent: Some(true),
+            treat_doc_strings_as_comments: Some(true),
+            ..Default::default()
+        });
+        let stats = self.stats.langs.entry(lang).or_insert(Lines {comments:0, code:0});
+        stats.comments += res.comments as u32;
+        stats.code += res.code as u32;
     }
 
     fn rust_code_stats(&mut self, file_content: &str) {
diff --git a/user_db/Cargo.toml b/user_db/Cargo.toml
index b369e8a..5422a53 100644
--- a/user_db/Cargo.toml
+++ b/user_db/Cargo.toml
@@ -14,4 +14,4 @@ rusqlite = "0.16"
 github_info = { path = "../github_info", version = "0.8.0" }
 repo_url = { git = "https://gitlab.com/crates.rs/repo_url.git" }
 failure = "0.1.1"
-parking_lot = "0.7.1"
+parking_lot = "0.9"