Drop anyhow dependency in graphql_query_derive

Author: tomhoule

graphql_client_cli/src/generate.rs

@@ -59,7 +59,7 @@ pub(crate) fn generate_code(params: CliCodegenParams) -> Result<()> {
         options.set_deprecation_strategy(deprecation_strategy);
     }
 
-    let gen = generate_module_token_stream(query_path.clone(), &schema_path, options)?;
+    let gen = generate_module_token_stream(query_path.clone(), &schema_path, options).unwrap();
 
     let generated_code = gen.to_string();
     let generated_code = if cfg!(feature = "rustfmt") && !no_formatting {

graphql_client_cli/src/introspect_schema.rs

@@ -1,3 +1,4 @@
+use anyhow::*;
 use graphql_client::GraphQLQuery;
 use reqwest::header::{HeaderMap, HeaderValue, ACCEPT, CONTENT_TYPE};
 use std::path::PathBuf;

graphql_client_codegen/src/lib.rs

@@ -36,7 +36,7 @@ use thiserror::Error;
 #[error("{0}")]
 struct GeneralError(String);
 
-type BoxError = Box<dyn std::error::Error + 'static>;
+type BoxError = Box<dyn std::error::Error + Send + Sync + 'static>;
 type CacheMap<T> = std::sync::Mutex<HashMap<std::path::PathBuf, T>>;
 
 lazy_static! {

graphql_query_derive/Cargo.toml

@@ -11,7 +11,6 @@ edition = "2018"
 proc-macro = true
 
 [dependencies]
-anyhow = "1.0"
 syn = { version = "^1.0", features = ["extra-traits"] }
 proc-macro2 = { version = "^1.0", features = [] }
 graphql_client_codegen = { path = "../graphql_client_codegen/", version = "0.9.0" }

graphql_query_derive/src/attributes.rs

@@ -1,4 +1,4 @@
-use anyhow::*;
+use crate::{BoxError, GeneralError};
 use graphql_client_codegen::deprecation::DeprecationStrategy;
 use graphql_client_codegen::normalization::Normalization;
 
@@ -11,13 +11,13 @@ fn path_to_match() -> syn::Path {
 }
 
 /// Extract an configuration parameter specified in the `graphql` attribute.
-pub fn extract_attr(ast: &syn::DeriveInput, attr: &str) -> Result<String, anyhow::Error> {
+pub fn extract_attr(ast: &syn::DeriveInput, attr: &str) -> Result<String, syn::Error> {
     let attributes = &ast.attrs;
     let graphql_path = path_to_match();
     let attribute = attributes
         .iter()
         .find(|attr| attr.path == graphql_path)
-        .ok_or_else(|| format_err!("The graphql attribute is missing"))?;
+        .ok_or_else(|| syn::Error::new_spanned(ast, "The graphql attribute is missing"))?;
     if let syn::Meta::List(items) = &attribute.parse_meta().expect("Attribute is well formatted") {
         for item in items.nested.iter() {
             if let syn::NestedMeta::Meta(syn::Meta::NameValue(name_value)) = item {
@@ -33,27 +33,27 @@ pub fn extract_attr(ast: &syn::DeriveInput, attr: &str) -> Result<String, anyhow
         }
     }
 
-    Err(format_err!("attribute not found"))
+    Err(syn::Error::new_spanned(ast, "Attribute not found"))
 }
 
 /// Get the deprecation from a struct attribute in the derive case.
 pub fn extract_deprecation_strategy(
     ast: &syn::DeriveInput,
-) -> Result<DeprecationStrategy, anyhow::Error> {
+) -> Result<DeprecationStrategy, BoxError> {
     extract_attr(&ast, "deprecated")?
         .to_lowercase()
         .as_str()
         .parse()
-        .map_err(|_| format_err!("{}", DEPRECATION_ERROR))
+        .map_err(|_| GeneralError(DEPRECATION_ERROR.to_owned()).into())
 }
 
 /// Get the deprecation from a struct attribute in the derive case.
-pub fn extract_normalization(ast: &syn::DeriveInput) -> Result<Normalization, anyhow::Error> {
+pub fn extract_normalization(ast: &syn::DeriveInput) -> Result<Normalization, BoxError> {
     extract_attr(&ast, "normalization")?
         .to_lowercase()
         .as_str()
         .parse()
-        .map_err(|_| format_err!("{}", NORMALIZATION_ERROR))
+        .map_err(|_| GeneralError(NORMALIZATION_ERROR.to_owned()).into())
 }
 
 #[cfg(test)]

graphql_query_derive/src/lib.rs

@@ -3,14 +3,30 @@ extern crate proc_macro;
 /// Derive-related code. This will be moved into graphql_query_derive.
 mod attributes;
 
-use anyhow::Context;
 use graphql_client_codegen::{
     generate_module_token_stream, CodegenMode, GraphQLClientCodegenOptions,
 };
-use std::path::{Path, PathBuf};
+use std::{
+    env,
+    fmt::Display,
+    path::{Path, PathBuf},
+};
 
 use proc_macro2::TokenStream;
 
+type BoxError = Box<dyn std::error::Error + 'static>;
+
+#[derive(Debug)]
+struct GeneralError(String);
+
+impl Display for GeneralError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_str(&self.0)
+    }
+}
+
+impl std::error::Error for GeneralError {}
+
 #[proc_macro_derive(GraphQLQuery, attributes(graphql))]
 pub fn derive_graphql_query(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
     match graphql_query_derive_inner(input) {
@@ -21,39 +37,37 @@ pub fn derive_graphql_query(input: proc_macro::TokenStream) -> proc_macro::Token
 
 fn graphql_query_derive_inner(
     input: proc_macro::TokenStream,
-) -> Result<proc_macro::TokenStream, anyhow::Error> {
+) -> Result<proc_macro::TokenStream, BoxError> {
     let input = TokenStream::from(input);
-    let ast = syn::parse2(input).expect("derive input parsing");
-    // .context("Derive input parsing.")?;
+    let ast = syn::parse2(input)?;
     let (query_path, schema_path) = build_query_and_schema_path(&ast)?;
     let options = build_graphql_client_derive_options(&ast, query_path.clone())?;
     Ok(
         generate_module_token_stream(query_path, &schema_path, options)
             .map(Into::into)
-            .context("Code generation failed.")?,
+            .map_err(|err| GeneralError(format!("Code generation failed: {}", err)))?,
     )
 }
 
-fn build_query_and_schema_path(
-    input: &syn::DeriveInput,
-) -> Result<(PathBuf, PathBuf), anyhow::Error> {
-    let cargo_manifest_dir = ::std::env::var("CARGO_MANIFEST_DIR")
-        .context("Checking that the CARGO_MANIFEST_DIR env variable is defined.")?;
+fn build_query_and_schema_path(input: &syn::DeriveInput) -> Result<(PathBuf, PathBuf), BoxError> {
+    let cargo_manifest_dir = env::var("CARGO_MANIFEST_DIR").map_err(|_err| {
+        GeneralError("Checking that the CARGO_MANIFEST_DIR env variable is defined.".into())
+    })?;
 
-    let query_path =
-        attributes::extract_attr(input, "query_path").context("Extracting query path.")?;
+    let query_path = attributes::extract_attr(input, "query_path")
+        .map_err(|err| GeneralError(format!("Error extracting query path. {}", err)))?;
     let query_path = format!("{}/{}", cargo_manifest_dir, query_path);
     let query_path = Path::new(&query_path).to_path_buf();
-    let schema_path =
-        attributes::extract_attr(input, "schema_path").context("Extracting schema path.")?;
+    let schema_path = attributes::extract_attr(input, "schema_path")
+        .map_err(|err| GeneralError(format!("Error extracting schema path. {}", err)))?;
     let schema_path = Path::new(&cargo_manifest_dir).join(schema_path);
     Ok((query_path, schema_path))
 }
 
 fn build_graphql_client_derive_options(
     input: &syn::DeriveInput,
     query_path: PathBuf,
-) -> Result<GraphQLClientCodegenOptions, anyhow::Error> {
+) -> Result<GraphQLClientCodegenOptions, BoxError> {
     let variables_derives = attributes::extract_attr(input, "variables_derives").ok();
     let response_derives = attributes::extract_attr(input, "response_derives").ok();