Bump version number

Bump reqwest from 0.9.17 to 0.9.19

Cargo.toml

@@ -1,27 +1,27 @@
 [package]
 name = "hoc"
-version = "0.9.2"
+version = "0.11.0"
 authors = ["Valentin Brandl <vbrandl@riseup.net>"]
 edition = "2018"
 build = "build.rs"
 
 [dependencies]
-actix-web = "1.0.0"
+actix-web = "1.0.5"
 badge = "0.2.0"
 bytes = "0.4.12"
-futures = "0.1.27"
+futures = "0.1.28"
 git2 = "0.9.1"
 lazy_static = "1.3.0"
-log = "0.4.6"
+log = "0.4.7"
 log4rs = "0.8.3"
 number_prefix = "0.3.0"
 openssl-probe = "0.1.2"
-reqwest = "0.9.17"
-serde = "1.0.91"
-serde_derive = "1.0.91"
-serde_json = "1.0.39"
-structopt = "0.2.16"
+reqwest = "0.9.19"
+serde = "1.0.97"
+serde_derive = "1.0.97"
+serde_json = "1.0.40"
+structopt = "0.2.18"
 
 [build-dependencies]
-ructe = "0.6.2"
+ructe = "0.7.0"
 vergen = "3.0.4"

scripts/find-active.sh

@@ -0,0 +1,10 @@
+#!/usr/bin/env sh
+
+set -e
+
+DIR=${1:-repos}
+
+for url in $(./scripts/list.sh "${DIR}")
+do
+    (curl "${url}" --silent | grep -q hitsofcode) && echo "${url}" &
+done

scripts/load-active.sh

@@ -0,0 +1,21 @@
+#!/usr/bin/env sh
+
+set -e
+
+ACTIVE=${1}
+
+if [ -z "${ACTIVE}" ]
+then
+    echo "Usage: $0 <list of active repos>"
+    exit 1
+fi
+
+while IFS= read -r url
+do
+    imgs=$(curl "${url}" --silent | grep hitsofcode | grep -o -P 'https://camo.githubusercontent.com/[a-z0-9]+/[a-z0-9]+')
+    [ -z "${imgs}" ] || echo "${url}"
+    for img in ${imgs}
+    do
+        curl "$img" --silent > /dev/null &
+    done
+done < "${ACTIVE}"

src/cache.rs

@@ -1,4 +1,4 @@
-use crate::Error;
+use crate::error::{Error, Result};
 use std::{
     borrow::Cow,
     fs::{create_dir_all, File, OpenOptions},
@@ -9,7 +9,7 @@ use std::{
 /// Enum to indicate the state of the cache
 pub(crate) enum CacheState<'a> {
     /// Current head and cached head are the same
-    Current(u64),
+    Current { count: u64, commits: u64 },
     /// Cached head is older than current head
     Old(Cache<'a>),
     /// No cache was found
@@ -17,11 +17,14 @@ pub(crate) enum CacheState<'a> {
 }
 
 impl<'a> CacheState<'a> {
-    pub(crate) fn read_from_file(path: impl AsRef<Path>, head: &str) -> Result<CacheState, Error> {
+    pub(crate) fn read_from_file(path: impl AsRef<Path>, head: &str) -> Result<CacheState> {
         if path.as_ref().exists() {
             let cache: Cache = serde_json::from_reader(BufReader::new(File::open(path)?))?;
             if cache.head == head {
-                Ok(CacheState::Current(cache.count))
+                Ok(CacheState::Current {
+                    count: cache.count,
+                    commits: cache.commits,
+                })
             } else {
                 Ok(CacheState::Old(cache))
             }
@@ -30,26 +33,35 @@ impl<'a> CacheState<'a> {
         }
     }
 
-    pub(crate) fn calculate_new_cache(self, count: u64, head: Cow<'a, str>) -> Cache {
+    pub(crate) fn calculate_new_cache(self, count: u64, commits: u64, head: Cow<'a, str>) -> Cache {
         match self {
             CacheState::Old(mut cache) => {
                 cache.head = head;
                 cache.count += count;
+                cache.commits += commits;
                 cache
             }
-            CacheState::No | CacheState::Current(_) => Cache { head, count },
+            CacheState::No | CacheState::Current { .. } => Cache {
+                head,
+                count,
+                commits,
+            },
         }
     }
 }
 
 #[derive(Serialize, Deserialize)]
 pub(crate) struct Cache<'a> {
+    /// HEAD commit ref
     pub head: Cow<'a, str>,
+    /// HoC value
     pub count: u64,
+    /// Number of commits
+    pub commits: u64,
 }
 
 impl<'a> Cache<'a> {
-    pub(crate) fn write_to_file(&self, path: impl AsRef<Path>) -> Result<(), Error> {
+    pub(crate) fn write_to_file(&self, path: impl AsRef<Path>) -> Result<()> {
         create_dir_all(path.as_ref().parent().ok_or(Error::Internal)?)?;
         serde_json::to_writer(
             OpenOptions::new()

src/error.rs

@@ -16,6 +16,7 @@ pub(crate) enum Error {
     Io(std::io::Error),
     Log(log::SetLoggerError),
     LogBuilder(log4rs::config::Errors),
+    Parse(std::num::ParseIntError),
     Serial(serde_json::Error),
 }
 
@@ -29,6 +30,7 @@ impl fmt::Display for Error {
             Error::Io(e) => write!(fmt, "Io({})", e),
             Error::Log(e) => write!(fmt, "Log({})", e),
             Error::LogBuilder(e) => write!(fmt, "LogBuilder({})", e),
+            Error::Parse(e) => write!(fmt, "Parse({})", e),
             Error::Serial(e) => write!(fmt, "Serial({})", e),
         }
     }
@@ -91,3 +93,9 @@ impl From<log4rs::config::Errors> for Error {
         Error::LogBuilder(err)
     }
 }
+
+impl From<std::num::ParseIntError> for Error {
+    fn from(err: std::num::ParseIntError) -> Self {
+        Error::Parse(err)
+    }
+}

src/main.rs

@@ -60,6 +60,7 @@ struct State {
 struct JsonResponse<'a> {
     head: &'a str,
     count: u64,
+    commits: u64,
 }
 
 fn pull(path: impl AsRef<Path>) -> Result<()> {
@@ -69,17 +70,13 @@ fn pull(path: impl AsRef<Path>) -> Result<()> {
     Ok(())
 }
 
-fn hoc(repo: &str, repo_dir: &str, cache_dir: &str) -> Result<(u64, String)> {
+fn hoc(repo: &str, repo_dir: &str, cache_dir: &str) -> Result<(u64, String, u64)> {
     let repo_dir = format!("{}/{}", repo_dir, repo);
     let cache_dir = format!("{}/{}.json", cache_dir, repo);
     let cache_dir = Path::new(&cache_dir);
-    let head = format!(
-        "{}",
-        Repository::open_bare(&repo_dir)?
-            .head()?
-            .target()
-            .ok_or(Error::Internal)?
-    );
+    let repo = Repository::open_bare(&repo_dir)?;
+    let head = format!("{}", repo.head()?.target().ok_or(Error::Internal)?);
+    let mut arg_commit_count = vec!["rev-list".to_string(), "--count".to_string()];
     let mut arg = vec![
         "log".to_string(),
         "--pretty=tformat:".to_string(),
@@ -94,16 +91,18 @@ fn hoc(repo: &str, repo_dir: &str, cache_dir: &str) -> Result<(u64, String)> {
     ];
     let cache = CacheState::read_from_file(&cache_dir, &head)?;
     match &cache {
-        CacheState::Current(res) => {
+        CacheState::Current { count, commits } => {
             info!("Using cache for {}", repo_dir);
-            return Ok((*res, head));
+            return Ok((*count, head, *commits));
         }
         CacheState::Old(cache) => {
             info!("Updating cache for {}", repo_dir);
             arg.push(format!("{}..HEAD", cache.head));
+            arg_commit_count.push(format!("{}..HEAD", cache.head));
         }
         CacheState::No => {
             info!("Creating cache for {}", repo_dir);
+            arg_commit_count.push("HEAD".to_string());
         }
     };
     arg.push("--".to_string());
@@ -114,6 +113,13 @@ fn hoc(repo: &str, repo_dir: &str, cache_dir: &str) -> Result<(u64, String)> {
         .output()?
         .stdout;
     let output = String::from_utf8_lossy(&output);
+    let output_commits = Command::new("git")
+        .args(&arg_commit_count)
+        .current_dir(&repo_dir)
+        .output()?
+        .stdout;
+    let output_commits = String::from_utf8_lossy(&output_commits);
+    let commits: u64 = output_commits.trim().parse()?;
     let count: u64 = output
         .lines()
         .map(|s| {
@@ -125,19 +131,24 @@ fn hoc(repo: &str, repo_dir: &str, cache_dir: &str) -> Result<(u64, String)> {
         })
         .sum();
 
-    let cache = cache.calculate_new_cache(count, (&head).into());
+    let cache = cache.calculate_new_cache(count, commits, (&head).into());
     cache.write_to_file(cache_dir)?;
 
-    Ok((cache.count, head))
+    Ok((cache.count, head, commits))
 }
 
-fn remote_exists(url: &str) -> Result<bool> {
-    Ok(CLIENT.head(url).send()?.status() == reqwest::StatusCode::OK)
+fn remote_exists(url: &str) -> impl Future<Item = bool, Error = Error> {
+    CLIENT
+        .head(url)
+        .send()
+        .map(|resp| resp.status() == reqwest::StatusCode::OK)
+        .from_err()
 }
 
 enum HocResult {
     Hoc {
         hoc: u64,
+        commits: u64,
         hoc_pretty: String,
         head: String,
         url: String,
@@ -156,15 +167,15 @@ where
     T: Service,
     F: Fn(HocResult) -> Result<HttpResponse>,
 {
-    futures::future::result(Ok(()))
-        .and_then(move |_| {
-            let repo = format!("{}/{}", data.0.to_lowercase(), data.1.to_lowercase());
-            let service_path = format!("{}/{}", T::domain(), repo);
-            let path = format!("{}/{}", state.repos, service_path);
+    let repo = format!("{}/{}", data.0.to_lowercase(), data.1.to_lowercase());
+    let service_path = format!("{}/{}", T::domain(), repo);
+    let path = format!("{}/{}", state.repos, service_path);
+    let url = format!("https://{}", service_path);
+    remote_exists(&url)
+        .and_then(move |remote_exists| {
             let file = Path::new(&path);
-            let url = format!("https://{}", service_path);
             if !file.exists() {
-                if !remote_exists(&url)? {
+                if !remote_exists {
                     warn!("Repository does not exist: {}", url);
                     return Ok(HocResult::NotFound);
                 }
@@ -176,15 +187,16 @@ where
                 REPO_COUNT.fetch_add(1, Ordering::Relaxed);
             }
             pull(&path)?;
-            let (hoc, head) = hoc(&service_path, &state.repos, &state.cache)?;
+            let (hoc, head, commits) = hoc(&service_path, &state.repos, &state.cache)?;
             let hoc_pretty = match NumberPrefix::decimal(hoc as f64) {
                 Standalone(hoc) => hoc.to_string(),
                 Prefixed(prefix, hoc) => format!("{:.1}{}", hoc, prefix),
             };
             Ok(HocResult::Hoc {
                 hoc,
+                commits,
                 hoc_pretty,
-                head,
+                head: head.to_string(),
                 url,
                 repo,
                 service_path,
@@ -199,9 +211,12 @@ fn json_hoc<T: Service>(
 ) -> impl Future<Item = HttpResponse, Error = Error> {
     let mapper = |r| match r {
         HocResult::NotFound => p404(),
-        HocResult::Hoc { hoc, head, .. } => Ok(HttpResponse::Ok().json(JsonResponse {
+        HocResult::Hoc {
+            hoc, head, commits, ..
+        } => Ok(HttpResponse::Ok().json(JsonResponse {
             head: &head,
             count: hoc,
+            commits,
         })),
     };
     handle_hoc_request::<T, _>(state, data, mapper)
@@ -248,6 +263,7 @@ fn overview<T: Service>(
         HocResult::NotFound => p404(),
         HocResult::Hoc {
             hoc,
+            commits,
             hoc_pretty,
             url,
             head,
@@ -266,6 +282,7 @@ fn overview<T: Service>(
                 &hoc_pretty,
                 &head,
                 &T::commit_url(&repo, &head),
+                commits,
             )?;
 
             let (tx, rx_body) = mpsc::unbounded();
@@ -328,8 +345,7 @@ fn favicon32() -> HttpResponse {
     HttpResponse::Ok().content_type("image/png").body(FAVICON)
 }
 
-fn main() -> Result<()> {
-    config::init()?;
+fn start_server() -> Result<()> {
     let interface = format!("{}:{}", OPT.host, OPT.port);
     let state = Arc::new(State {
         repos: OPT.outdir.display().to_string(),
@@ -358,3 +374,8 @@ fn main() -> Result<()> {
     .bind(interface)?
     .run()?)
 }
+
+fn main() -> Result<()> {
+    config::init()?;
+    start_server()
+}

src/statics.rs

@@ -15,7 +15,7 @@ pub(crate) const CSS: &str = include_str!("../static/tacit-css.min.css");
 pub(crate) const FAVICON: &[u8] = include_bytes!("../static/favicon32.png");
 
 lazy_static! {
-    pub(crate) static ref CLIENT: reqwest::Client = reqwest::Client::new();
+    pub(crate) static ref CLIENT: reqwest::r#async::Client = reqwest::r#async::Client::new();
     pub(crate) static ref OPT: Opt = Opt::from_args();
     pub(crate) static ref REPO_COUNT: AtomicUsize =
         AtomicUsize::new(count_repositories(&OPT.outdir).unwrap());

templates/index.rs.html

@@ -46,17 +46,18 @@ alt="example badge" /></a>
 </pre>
 
 <p>
-You can also request the HoC as JSON by appending <code>/json</code> to the request path. This will return a JSON
-object with two fields: <code>count</code> and <code>head</code> with count being the HoC value and head being the
-commit ref of <code>HEAD</code>. Requesting
-<a href="https://@domain/github/vbrandl/hoc/json">https://@domain/github/vbrandl/hoc/json</a> might return something
-along the lines of
+You can also request the HoC as JSON by appending <code>/json</code> to the request path. This will return a JSON object
+with three fields: <code>count</code> (the HoC value), <code>commits</code> (the number of commits) and
+<code>head</code> (the commit ref of HEAD). Requesting <a
+href="https://@domain/github/vbrandl/hoc/json">https://@domain/github/vbrandl/hoc/json</a> might return something along
+the lines of
 </p>
 
 <pre>
 &#123;
-    "head" : "05736ee3ba256ec9a7227c436aef2bf43db109ab",
-    "count": 7582
+    "head": "1f01c3b964b018fb0c0c2c5b572bf4ace2968546",
+    "count": 8324,
+    "commits": 223
 &#125;
 </pre>
 

templates/overview.rs.html

@@ -1,12 +1,13 @@
 @use super::base;
 @use crate::statics::VersionInfo;
 
-@(version_info: VersionInfo, repo_count: usize, domain: &str, path: &str, url: &str, hoc: u64, hoc_pretty: &str, head: &str, commit_url: &str)
+@(version_info: VersionInfo, repo_count: usize, domain: &str, path: &str, url: &str, hoc: u64, hoc_pretty: &str, head: &str, commit_url: &str, commits: u64)
 
 @:base("Hits-of-Code Badges", "Overview", {
 
 <p>
-The project <a href="@url">@url</a> has <strong>@hoc_pretty</strong> (exactly @hoc) hits of code at <a href="@commit_url">@head</a>.
+The project <a href="@url">@url</a> has <strong>@hoc_pretty</strong> (exactly @hoc) hits of code at
+<a href="@commit_url">@head</a>. The repository contains <strong>@commits</strong> commits.
 </p>
 
 <p>