Chore: a few misc refactors

src/parse/ignoring/mod.rs

@@ -26,7 +26,7 @@ macro_rules! is_ignore_type {
       $input_object_names_set:ident,
       $scalar_names_set:ident,
       $union_names_set:ident,
-      $inerface_names_set:ident) => {
+      $interface_names_set:ident) => {
         match $typ {
             TypeDef::Object(Object { name, .. }) => $object_names_set.contains(&name),
             TypeDef::Enum(Enum { name, .. }) => $enum_names_set.contains(&name),
@@ -35,7 +35,7 @@ macro_rules! is_ignore_type {
             }
             TypeDef::Scalar(Scalar { name, .. }) => $scalar_names_set.contains(&name),
             TypeDef::Union(Union { name, .. }) => $union_names_set.contains(&name),
-            TypeDef::Interface(Interface { name, .. }) => $inerface_names_set.contains(&name),
+            TypeDef::Interface(Interface { name, .. }) => $interface_names_set.contains(&name),
             _ => false,
         }
     };

src/parse/structured/schema.rs

@@ -268,6 +268,13 @@ pub enum TypeDef<'a> {
     Interface(&'a Interface),
     AsyncGraphqlPreserved(String),
 }
+
+impl<'a> NameString for TypeDef<'a> {
+    fn name_string(&self) -> String {
+        self.name()
+    }
+}
+
 impl<'a> TypeDef<'a> {
     is! {Primitive}
     is! {Object}

src/render/mod.rs

@@ -21,6 +21,7 @@ mod utils;
 use super::parse;
 use super::parse::*;
 use crate::config::{Phase, RendererConfig};
+use crate::parse::TypeDef::{Enum, InputObject, Interface, Object, Union};
 use anyhow::{anyhow, Result};
 use comment::*;
 use files::{fmt_file, pathbuf_to_str};
@@ -36,12 +37,14 @@ pub struct RenderContext<'a> {
 
 impl<'a> RenderContext<'a> {
     pub fn parent_name(&self) -> String {
-        match self.parent {
-            parse::TypeDef::Object(obj) => format!("{}", obj.name_string()),
-            parse::TypeDef::Enum(obj) => format!("{}", obj.name_string()),
-            parse::TypeDef::InputObject(obj) => format!("{}", obj.name_string()),
-            parse::TypeDef::Union(obj) => format!("{}", obj.name_string()),
-            parse::TypeDef::Interface(obj) => format!("{}", obj.name_string()),
+        match &self.parent {
+            obj @ Object(_)
+            | obj @ Enum(_)
+            | obj @ InputObject(_)
+            | obj @ Union(_)
+            | obj @ Interface(_) => {
+                format!("{}", obj.name_string())
+            }
             _ => panic!("invalid parent : {:?}", self.parent),
         }
     }

src/render/typ.rs

@@ -1,3 +1,7 @@
+use crate::parse::TypeDef::{
+    AsyncGraphqlPreserved, Enum, InputObject, Interface, Object, Primitive, Scalar, Union,
+};
+
 use super::super::parse::{self, *};
 use super::RenderContext;
 use anyhow::Result;
@@ -40,60 +44,30 @@ fn type_def_token(
 ) -> Result<TokenStream> {
     //TODO() impl
     let result = match type_def {
-        parse::TypeDef::Primitive(primitive) => {
-            let name = format_ident!("{}", primitive.rust_type());
-            quote! { #name }
-        }
-        parse::TypeDef::Object(object) => {
-            let recursive = if let parse::TypeDef::InputObject(parent) = render_context.parent {
-                parent.name == object.name
-            } else {
-                false
-            };
-
-            let name: TokenStream = if recursive {
-                format!("Box<{}>", object.name_string()).parse().unwrap()
-            } else {
-                format!("{}", object.name_string()).parse().unwrap()
-            };
-
+        Primitive(obj) => {
+            let name = format_ident!("{}", obj.rust_type());
             quote! { #name }
         }
-        parse::TypeDef::Enum(enum_kind) => {
-            let name = format_ident!("{}", enum_kind.name_string());
-            quote! { #name }
-        }
-        parse::TypeDef::InputObject(input_object) => {
-            let recursive = if let parse::TypeDef::InputObject(parent) = render_context.parent {
-                parent.name == input_object.name
+        obj @ Object(_) | obj @ InputObject(_) => {
+            let recursive = if let InputObject(parent) = render_context.parent {
+                parent.name == obj.name()
             } else {
                 false
             };
 
             let name: TokenStream = if recursive {
-                format!("Box<{}>", input_object.name_string())
-                    .parse()
-                    .unwrap()
+                format!("Box<{}>", obj.name_string()).parse().unwrap()
             } else {
-                format!("{}", input_object.name_string()).parse().unwrap()
+                format!("{}", obj.name_string()).parse().unwrap()
             };
             quote! { #name }
         }
-        parse::TypeDef::Scalar(scalar) => {
-            let name = format_ident!("{}", scalar.name_string());
+        obj @ Enum(_) | obj @ Scalar(_) | obj @ Union(_) | obj @ Interface(_) => {
+            let name = format_ident!("{}", obj.name_string());
             quote! { #name }
         }
-        parse::TypeDef::Union(union) => {
-            let name = format_ident!("{}", union.name_string());
-            quote! { #name }
-        }
-        parse::TypeDef::Interface(interface) => {
-            let name = format_ident!("{}", interface.name_string());
-            quote! { #name }
-        }
-
-        parse::TypeDef::AsyncGraphqlPreserved(type_name) => {
-            let name = format_ident!("{}", type_name);
+        AsyncGraphqlPreserved(obj) => {
+            let name = format_ident!("{}", obj);
             quote! { #name }
         }
     };