Refactored metrics_py

Author: luigig44

src/lib.rs

@@ -2,12 +2,11 @@ use std::path::PathBuf;
 
 use pyo3::prelude::*;
 
-use pyo3::types::PyDict;
 use rust_code_analysis::{AstCallback, AstCfg, AstPayload, LANG, action, guess_language};
 
 use rust_code_analysis::{Callback, ParserTrait, rm_comments};
 mod metrics;
-use metrics::{MetricsPayload, MetricsResponse, metrics_rust};
+use metrics::{MetricsPayload, metrics_rust};
 /// Unit structure to implement the `Callback` trait.
 #[derive(Debug)]
 pub struct CommentRemoval;
@@ -45,28 +44,21 @@ fn comment_removal(file_name: String, code: String) -> PyResult<String> {
 #[pyfunction]
 fn metrics_py(file_name: String, code: String, unit: bool) -> PyResult<Py<PyAny>> {
     let payload = MetricsPayload {
-        id: "1".to_string(),
         file_name,
         code,
         unit,
     };
     let response = metrics_rust(payload);
 
     response
-        .map_err(|e| PyErr::new::<pyo3::exceptions::PyValueError, _>(e.error)) // Unknown language
-        .and_then(|response| match response.spaces {
-            None => Err(PyErr::new::<pyo3::exceptions::PyValueError, _>(
-                "Failed to compute metrics",
-            )),
-            Some(_) => Ok(response),
-        })
         .and_then(|response| {
             Python::with_gil(|py| {
                 pythonize::pythonize(py, &response)
-                    .map_err(|e| PyErr::new::<pyo3::exceptions::PyValueError, _>(e.to_string()))
+                    .map_err(|e| e.to_string())
                     .map(|v| v.into())
             })
         })
+        .map_err(|e| PyErr::new::<pyo3::exceptions::PyValueError, _>(e))
 }
 
 /// A Python module implemented in Rust.

src/metrics.rs

@@ -1,14 +1,11 @@
 use std::path::PathBuf;
 
 use rust_code_analysis::{guess_language, metrics, Callback, FuncSpace, ParserTrait, action};
-use serde::Serialize;
 
 
 /// Payload containing source code used to compute metrics.
 #[derive(Debug)]
 pub struct MetricsPayload {
-    /// Payload identifier.
-    pub id: String,
     /// Source code filename.
     pub file_name: String,
     /// Source code used to compute metrics.
@@ -19,29 +16,15 @@ pub struct MetricsPayload {
 
 /// Server response containing metrics for every space present in
 /// the requested source code.
-#[derive(Debug, Serialize)]
-pub struct MetricsResponse {
-    /// Server response identifier.
-    pub id: String,
-    /// Source code programming language.
-    pub language: String,
-    /// Metrics for every space contained in the requested source code.
-    ///
-    /// If `None`, an error occurred processing the request.
-    pub spaces: Option<FuncSpace>,
-}
+pub type MetricsResponse = Result<FuncSpace, String>;
 
 /// Server request configuration.
 #[derive(Debug)]
 pub struct MetricsCfg {
-    /// Request identifier.
-    pub id: String,
     /// Path to the source file.
     pub path: PathBuf,
     /// Flag to consider only unit space metrics.
     pub unit: bool,
-    /// Source code programming language.
-    pub language: String,
 }
 
 /// Unit structure to implement the `Callback` trait.
@@ -53,7 +36,7 @@ impl Callback for MetricsCallback {
 
     fn call<T: ParserTrait>(cfg: Self::Cfg, parser: &T) -> Self::Res {
         let spaces = metrics(parser, &cfg.path);
-        let spaces = if cfg.unit {
+        let spaces =if cfg.unit {
             if let Some(mut spaces) = spaces {
                 spaces.spaces.clear();
                 Some(spaces)
@@ -63,43 +46,28 @@ impl Callback for MetricsCallback {
         } else {
             spaces
         };
-
-        MetricsResponse {
-            id: cfg.id,
-            language: cfg.language,
-            spaces,
-        }
+        spaces.map_or(Err("Failed to compute metrics".to_string()), Ok)
     }
 }
 
-#[derive(Debug)]
-pub struct Error {
-    pub id: String,
-    pub error: &'static str,
-}
 
-pub fn metrics_rust(payload: MetricsPayload) -> Result<MetricsResponse, Error> {
+pub fn metrics_rust(payload: MetricsPayload) -> MetricsResponse {
     let path = PathBuf::from(&payload.file_name);
     let buf = payload.code.into_bytes();
-    let (language, name) = guess_language(&buf, &path);
+    let (language, _name) = guess_language(&buf, &path);
     if let Some(language) = language {
         let cfg = MetricsCfg {
-            id: payload.id,
             path,
             unit: payload.unit,
-            language: name.to_string(),
         };
-        Ok(action::<MetricsCallback>(
+        action::<MetricsCallback>(
             &language,
             buf,
             &PathBuf::from(""),
             None,
             cfg,
-        ))
+        )
     } else {
-        Err(Error {
-            id: payload.id,
-            error: "The file extension doesn't correspond to a valid language",
-        })
+        Err("The file extension doesn't correspond to a valid language".to_string())
     }
 }