Bump version number

Bump serde_json from 1.0.39 to 1.0.40

Cargo.toml

@@ -1,27 +1,27 @@
 [package]
 name = "hoc"
-version = "0.8.1"
+version = "0.9.5"
 authors = ["Valentin Brandl <vbrandl@riseup.net>"]
 edition = "2018"
 build = "build.rs"
 
 [dependencies]
-actix-web = "1.0.0"
+actix-web = "1.0.3"
 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"
 log4rs = "0.8.3"
 number_prefix = "0.3.0"
 openssl-probe = "0.1.2"
-reqwest = "0.9.17"
+reqwest = "0.9.18"
-serde = "1.0.91"
+serde = "1.0.94"
-serde_derive = "1.0.91"
+serde_derive = "1.0.94"
-serde_json = "1.0.39"
+serde_json = "1.0.40"
-structopt = "0.2.16"
+structopt = "0.2.18"
 
 [build-dependencies]
-ructe = "0.6.2"
+ructe = "0.6.4"
 vergen = "3.0.4"

README.md

@@ -20,8 +20,14 @@ The API is as simple as
 https://<host>/<service>/<user>/<repo>
 ```
 
-where `<service>` is one of `gitub`, `gitlab` or `bitbucket`.
+where `<service>` is one of `gitub`, `gitlab` or `bitbucket`. The HoC data can also be received as JSON by appending
+`/json` to the reuqest path:
 
+```
+https://<host>/<service>/<user>/<repo>/json
+```
+
+There is also an overview page available via `https://<host>/view/<service>/<user>/<repo>`
 
 ## Building
 

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},
@@ -17,7 +17,7 @@ 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 {
@@ -49,7 +49,7 @@ pub(crate) struct Cache<'a> {
 }
 
 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/main.rs

@@ -56,6 +56,12 @@ struct State {
     cache: String,
 }
 
+#[derive(Serialize)]
+struct JsonResponse<'a> {
+    head: &'a str,
+    count: u64,
+}
+
 fn pull(path: impl AsRef<Path>) -> Result<()> {
     let repo = Repository::open_bare(path)?;
     let mut origin = repo.find_remote("origin")?;
@@ -150,46 +156,55 @@ where
     T: Service,
     F: Fn(HocResult) -> Result<HttpResponse>,
 {
-    hoc_request::<T>(state, data).and_then(mapper)
+    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 file = Path::new(&path);
+            let url = format!("https://{}", service_path);
+            if !file.exists() {
+                if !remote_exists(&url)? {
+                    warn!("Repository does not exist: {}", url);
+                    return Ok(HocResult::NotFound);
+                }
+                info!("Cloning {} for the first time", url);
+                create_dir_all(file)?;
+                let repo = Repository::init_bare(file)?;
+                repo.remote_add_fetch("origin", "refs/heads/*:refs/heads/*")?;
+                repo.remote_set_url("origin", &url)?;
+                REPO_COUNT.fetch_add(1, Ordering::Relaxed);
+            }
+            pull(&path)?;
+            let (hoc, head) = 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,
+                hoc_pretty,
+                head,
+                url,
+                repo,
+                service_path,
+            })
+        })
+        .and_then(mapper)
 }
 
-fn hoc_request<T: Service>(
+fn json_hoc<T: Service>(
     state: web::Data<Arc<State>>,
     data: web::Path<(String, String)>,
-) -> impl Future<Item = HocResult, Error = Error> {
+) -> impl Future<Item = HttpResponse, Error = Error> {
-    futures::future::result(Ok(())).and_then(move |_| {
+    let mapper = |r| match r {
-        let repo = format!("{}/{}", data.0.to_lowercase(), data.1.to_lowercase());
+        HocResult::NotFound => p404(),
-        let service_path = format!("{}/{}", T::domain(), repo);
+        HocResult::Hoc { hoc, head, .. } => Ok(HttpResponse::Ok().json(JsonResponse {
-        let path = format!("{}/{}", state.repos, service_path);
+            head: &head,
-        let file = Path::new(&path);
+            count: hoc,
-        let url = format!("https://{}", service_path);
+        })),
-        if !file.exists() {
+    };
-            if !remote_exists(&url)? {
+    handle_hoc_request::<T, _>(state, data, mapper)
-                warn!("Repository does not exist: {}", url);
-                return Ok(HocResult::NotFound);
-            }
-            info!("Cloning {} for the first time", url);
-            create_dir_all(file)?;
-            let repo = Repository::init_bare(file)?;
-            repo.remote_add_fetch("origin", "refs/heads/*:refs/heads/*")?;
-            repo.remote_set_url("origin", &url)?;
-            REPO_COUNT.fetch_add(1, Ordering::Relaxed);
-        }
-        pull(&path)?;
-        let (hoc, head) = 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,
-            hoc_pretty,
-            head,
-            url,
-            repo,
-            service_path,
-        })
-    })
 }
 
 fn calculate_hoc<T: Service>(
@@ -331,6 +346,9 @@ fn main() -> Result<()> {
             .service(web::resource("/github/{user}/{repo}").to_async(calculate_hoc::<GitHub>))
             .service(web::resource("/gitlab/{user}/{repo}").to_async(calculate_hoc::<Gitlab>))
             .service(web::resource("/bitbucket/{user}/{repo}").to_async(calculate_hoc::<Bitbucket>))
+            .service(web::resource("/github/{user}/{repo}/json").to_async(json_hoc::<GitHub>))
+            .service(web::resource("/gitlab/{user}/{repo}/json").to_async(json_hoc::<Gitlab>))
+            .service(web::resource("/bitbucket/{user}/{repo}/json").to_async(json_hoc::<Bitbucket>))
             .service(web::resource("/view/github/{user}/{repo}").to_async(overview::<GitHub>))
             .service(web::resource("/view/gitlab/{user}/{repo}").to_async(overview::<Gitlab>))
             .service(web::resource("/view/bitbucket/{user}/{repo}").to_async(overview::<Bitbucket>))

templates/index.rs.html

@@ -45,6 +45,21 @@ would render this badge:
 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
+</p>
+
+<pre>
+&#123;
+    "head" : "05736ee3ba256ec9a7227c436aef2bf43db109ab",
+    "count": 7582
+&#125;
+</pre>
+
 <h2>Badge Generator</h2>
 
 <form method="post" action="/generate">