Merge pull request #111 from mathstuf/cache-input-files

tomhoule · web-flow · commit f495ee76046f · 2018-09-15T18:37:57.000+02:00
Cache input files
diff --git a/graphql_query_derive/Cargo.toml b/graphql_query_derive/Cargo.toml
@@ -11,6 +11,7 @@ proc-macro = true
 
 [dependencies]
 failure = "0.1"
+lazy_static = "1.0"
 quote = "^0.6"
 syn = "0.14"
 proc-macro2 = { version = "0.4", features = [] }
diff --git a/graphql_query_derive/src/constants.rs b/graphql_query_derive/src/constants.rs
@@ -1,17 +1,16 @@
 use deprecation::DeprecationStatus;
 use field_type::FieldType;
 use objects::GqlObjectField;
-use proc_macro2::{Ident, Span};
 
 pub(crate) const TYPENAME_FIELD: &str = "__typename";
 
-pub(crate) fn string_type() -> Ident {
-    Ident::new("String", Span::call_site())
+pub(crate) fn string_type() -> String {
+    "String".to_string()
 }
 
 #[cfg(test)]
-pub(crate) fn float_type() -> Ident {
-    Ident::new("Float", Span::call_site())
+pub(crate) fn float_type() -> String {
+    "Float".to_string()
 }
 
 pub(crate) fn typename_field() -> GqlObjectField {
diff --git a/graphql_query_derive/src/enums.rs b/graphql_query_derive/src/enums.rs
@@ -2,13 +2,13 @@ use proc_macro2::{Ident, Span, TokenStream};
 
 pub const ENUMS_PREFIX: &str = "";
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug, Clone, PartialEq)]
 pub struct EnumVariant {
     pub description: Option<String>,
     pub name: String,
 }
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug, Clone, PartialEq)]
 pub struct GqlEnum {
     pub description: Option<String>,
     pub name: String,
diff --git a/graphql_query_derive/src/field_type.rs b/graphql_query_derive/src/field_type.rs
@@ -7,7 +7,7 @@ use schema::DEFAULT_SCALARS;
 
 #[derive(Clone, Debug, PartialEq, Hash)]
 pub enum FieldType {
-    Named(Ident),
+    Named(String),
     Optional(Box<FieldType>),
     Vector(Box<FieldType>),
 }
@@ -21,27 +21,23 @@ impl FieldType {
             prefix.to_string()
         };
         match &self {
-            FieldType::Named(name) => {
-                let name_string = name.to_string();
-
-                let name = if context.schema.scalars.contains_key(&name_string) || DEFAULT_SCALARS
+            FieldType::Named(ref name) => {
+                let full_name = if context.schema.scalars.contains_key(name) || DEFAULT_SCALARS
                     .iter()
-                    .any(|elem| elem == &name_string.as_str())
+                    .any(|elem| elem == name)
                 {
                     name.clone()
-                } else if context.schema.enums.contains_key(&name_string) {
-                    Ident::new(
-                        &format!("{}{}", ENUMS_PREFIX, &name_string),
-                        Span::call_site(),
-                    )
+                } else if context.schema.enums.contains_key(name) {
+                    format!("{}{}", ENUMS_PREFIX, name)
                 } else {
                     if prefix.is_empty() {
                         panic!("Empty prefix for {:?}", self);
                     }
-                    Ident::new(&prefix, Span::call_site())
+                    prefix
                 };
+                let full_name = Ident::new(&full_name, Span::call_site());
 
-                quote!(#name)
+                quote!(#full_name)
             }
             FieldType::Optional(inner) => {
                 let inner = inner.to_rust(context, &prefix);
@@ -89,7 +85,7 @@ fn from_schema_type_inner(inner: graphql_parser::schema::Type, non_null: bool) -
             }
         }
         graphql_parser::schema::Type::NamedType(name) => {
-            let f = FieldType::Named(Ident::new(&name, Span::call_site()));
+            let f = FieldType::Named(name);
             if non_null {
                 f
             } else {
@@ -120,10 +116,7 @@ fn from_json_type_inner(inner: &introspection_response::TypeRef, non_null: bool)
             }
         }
         Some(_) => {
-            let f = FieldType::Named(Ident::new(
-                &inner.name.expect("type name"),
-                Span::call_site(),
-            ));
+            let f = FieldType::Named(inner.name.expect("type name").clone());
             if non_null {
                 f
             } else {
@@ -157,17 +150,14 @@ mod tests {
         let ty = GqlParserType::NamedType("Cat".to_string());
         assert_eq!(
             FieldType::from(ty),
-            FieldType::Optional(Box::new(FieldType::Named(Ident::new(
-                "Cat",
-                Span::call_site()
-            ))))
+            FieldType::Optional(Box::new(FieldType::Named("Cat".to_string())))
         );
 
         let ty = GqlParserType::NonNullType(Box::new(GqlParserType::NamedType("Cat".to_string())));
 
         assert_eq!(
             FieldType::from(ty),
-            FieldType::Named(Ident::new("Cat", Span::call_site()))
+            FieldType::Named("Cat".to_string())
         );
     }
 
@@ -182,10 +172,7 @@ mod tests {
         };
         assert_eq!(
             FieldType::from(ty),
-            FieldType::Optional(Box::new(FieldType::Named(Ident::new(
-                "Cat",
-                Span::call_site()
-            ))))
+            FieldType::Optional(Box::new(FieldType::Named("Cat".to_string())))
         );
 
         let ty = FullTypeFieldsType {
@@ -201,7 +188,7 @@ mod tests {
         };
         assert_eq!(
             FieldType::from(ty),
-            FieldType::Named(Ident::new("Cat", Span::call_site()))
+            FieldType::Named("Cat".to_string())
         );
     }
 }
diff --git a/graphql_query_derive/src/inputs.rs b/graphql_query_derive/src/inputs.rs
@@ -9,7 +9,7 @@ use query::QueryContext;
 use std::collections::HashMap;
 
 /// Represents an input object type from a GraphQL schema
-#[derive(Debug, PartialEq)]
+#[derive(Debug, Clone, PartialEq)]
 pub struct GqlInput {
     pub description: Option<String>,
     pub name: String,
@@ -116,10 +116,7 @@ mod tests {
                     GqlObjectField {
                         description: None,
                         name: "offsprings".to_string(),
-                        type_: FieldType::Vector(Box::new(FieldType::Named(Ident::new(
-                            "Cat",
-                            Span::call_site(),
-                        )))),
+                        type_: FieldType::Vector(Box::new(FieldType::Named("Cat".to_string()))),
                         deprecation: DeprecationStatus::Current,
                     },
                 ),
@@ -128,10 +125,7 @@ mod tests {
                     GqlObjectField {
                         description: None,
                         name: "requirements".to_string(),
-                        type_: FieldType::Optional(Box::new(FieldType::Named(Ident::new(
-                            "CatRequirements",
-                            Span::call_site(),
-                        )))),
+                        type_: FieldType::Optional(Box::new(FieldType::Named("CatRequirements".to_string()))),
                         deprecation: DeprecationStatus::Current,
                     },
                 ),
diff --git a/graphql_query_derive/src/interfaces.rs b/graphql_query_derive/src/interfaces.rs
@@ -8,7 +8,7 @@ use std::borrow::Cow;
 use std::collections::HashSet;
 use unions::union_variants;
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug, Clone, PartialEq)]
 pub struct GqlInterface {
     pub description: Option<String>,
     pub implemented_by: HashSet<String>,
diff --git a/graphql_query_derive/src/lib.rs b/graphql_query_derive/src/lib.rs
@@ -4,6 +4,8 @@
 extern crate failure;
 extern crate graphql_parser;
 extern crate heck;
+#[macro_use]
+extern crate lazy_static;
 extern crate proc_macro;
 extern crate proc_macro2;
 extern crate serde;
@@ -42,6 +44,13 @@ mod tests;
 use heck::*;
 use proc_macro2::{Ident, Span};
 
+type CacheMap<T> = ::std::sync::Mutex<::std::collections::hash_map::HashMap<::std::path::PathBuf, T>>;
+
+lazy_static! {
+    static ref SCHEMA_CACHE: CacheMap<schema::Schema> = CacheMap::default();
+    static ref QUERY_CACHE: CacheMap<(String, graphql_parser::query::Document)> = CacheMap::default();
+}
+
 #[proc_macro_derive(GraphQLQuery, attributes(graphql))]
 pub fn graphql_query_derive(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
     let input = TokenStream::from(input);
@@ -51,19 +60,19 @@ pub fn graphql_query_derive(input: proc_macro::TokenStream) -> proc_macro::Token
 }
 
 fn read_file(
-    path: impl AsRef<::std::path::Path> + ::std::fmt::Debug,
+    path: &::std::path::Path,
 ) -> Result<String, failure::Error> {
     use std::io::prelude::*;
 
     let mut out = String::new();
-    let mut file = ::std::fs::File::open(&path).map_err(|io_err| {
+    let mut file = ::std::fs::File::open(path).map_err(|io_err| {
         let err: failure::Error = io_err.into();
         err.context(format!(
             r#"
-            Could not find file with path: {:?}
+            Could not find file with path: {}
             Hint: file paths in the GraphQLQuery attribute are relative to the project root (location of the Cargo.toml). Example: query_path = "src/my_query.graphql".
             "#,
-            path
+            path.display()
         ))
     })?;
     file.read_to_string(&mut out)?;
@@ -88,29 +97,52 @@ fn impl_gql_query(input: &syn::DeriveInput) -> Result<TokenStream, failure::Erro
         .unwrap_or(deprecation::DeprecationStrategy::Warn);
 
     // We need to qualify the query with the path to the crate it is part of
-    let query_path = format!("{}/{}", cargo_manifest_dir, query_path);
-    let query_string = read_file(&query_path)?;
-    let query = graphql_parser::parse_query(&query_string)?;
+    let query_path = ::std::path::Path::new(&cargo_manifest_dir).join(query_path);
+    // Check the query cache.
+    let (query_string, query) = {
+        let mut lock = QUERY_CACHE.lock().expect("query cache is poisoned");
+        match lock.entry(query_path) {
+            ::std::collections::hash_map::Entry::Occupied(o) => o.get().clone(),
+            ::std::collections::hash_map::Entry::Vacant(v) => {
+                let query_string = read_file(v.key())?;
+                let query = graphql_parser::parse_query(&query_string)?;
+                v.insert((query_string, query)).clone()
+            },
+        }
+    };
 
     // We need to qualify the schema with the path to the crate it is part of
     let schema_path = ::std::path::Path::new(&cargo_manifest_dir).join(schema_path);
-    let schema_string = read_file(&schema_path)?;
-
-    let extension = schema_path
-        .extension()
-        .and_then(|e| e.to_str())
-        .unwrap_or("INVALID");
-
-    let schema = match extension {
-        "graphql" | "gql" => {
-            let s = graphql_parser::schema::parse_schema(&schema_string)?;
-            schema::Schema::from(s)
-        }
-        "json" => {
-            let parsed: FullResponse<introspection_response::IntrospectionResponse> = ::serde_json::from_str(&schema_string)?;
-            schema::Schema::from(parsed.data)
+    // Check the schema cache.
+    let schema = {
+        let mut lock = SCHEMA_CACHE.lock().expect("schema cache is poisoned");
+        match lock.entry(schema_path) {
+            ::std::collections::hash_map::Entry::Occupied(o) => o.get().clone(),
+            ::std::collections::hash_map::Entry::Vacant(v) => {
+                let schema_string = read_file(v.key())?;
+                let schema = {
+                    let extension = v
+                        .key()
+                        .extension()
+                        .and_then(|e| e.to_str())
+                        .unwrap_or("INVALID");
+
+                    match extension {
+                        "graphql" | "gql" => {
+                            let s = graphql_parser::schema::parse_schema(&schema_string)?;
+                            schema::Schema::from(s)
+                        }
+                        "json" => {
+                            let parsed: FullResponse<introspection_response::IntrospectionResponse> = ::serde_json::from_str(&schema_string)?;
+                            schema::Schema::from(parsed.data)
+                        }
+                        extension => panic!("Unsupported extension for the GraphQL schema: {} (only .json and .graphql are supported)", extension)
+                    }
+                };
+
+                v.insert(schema).clone()
+            },
         }
-        extension => panic!("Unsupported extension for the GraphQL schema: {} (only .json and .graphql are supported)", extension)
     };
 
     let module_name = Ident::new(&input.ident.to_string().to_snake_case(), Span::call_site());
diff --git a/graphql_query_derive/src/objects.rs b/graphql_query_derive/src/objects.rs
@@ -9,7 +9,7 @@ use selection::*;
 use shared::{field_impls_for_selection, response_fields_for_selection};
 use std::borrow::Cow;
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug, Clone, PartialEq)]
 pub struct GqlObject {
     pub description: Option<String>,
     pub fields: Vec<GqlObjectField>,
diff --git a/graphql_query_derive/src/scalars.rs b/graphql_query_derive/src/scalars.rs
@@ -1,6 +1,6 @@
 use proc_macro2;
 
-#[derive(Debug, PartialEq, PartialOrd, Ord, Eq)]
+#[derive(Debug, Clone, PartialEq, PartialOrd, Ord, Eq)]
 pub struct Scalar {
     pub name: String,
     pub description: Option<String>,
diff --git a/graphql_query_derive/src/schema.rs b/graphql_query_derive/src/schema.rs
diff --git a/graphql_query_derive/src/unions.rs b/graphql_query_derive/src/unions.rs
