Merge pull request #5 from Keats/clippy

tailhook · web-flow · commit ab8d7e63fb28 · 2018-02-08T00:18:39.000+02:00
Clippy
diff --git a/src/format.rs b/src/format.rs
@@ -1,6 +1,7 @@
 //! Formatting graphql
 use std::default::Default;
 
+#[derive(Debug, PartialEq)]
 pub(crate) struct Formatter<'a> {
     buf: String,
     style: &'a Style,
@@ -44,37 +45,45 @@ impl<'a> Formatter<'a> {
             indent: 0,
         }
     }
+
     pub fn indent(&mut self) {
         for _ in 0..self.indent {
             self.buf.push(' ');
         }
     }
+
     pub fn endline(&mut self) {
         self.buf.push('\n');
     }
+
     pub fn start_block(&mut self) {
         self.buf.push('{');
         self.endline();
         self.indent += self.style.indent;
     }
+
     pub fn end_block(&mut self) {
         self.indent = self.indent.checked_sub(self.style.indent)
             .expect("negative indent");
         self.indent();
         self.buf.push('}');
         self.endline();
     }
+
     pub fn margin(&mut self) {
-        if self.buf.len() != 0 {
+        if !self.buf.is_empty() {
             self.buf.push('\n');
         }
     }
+
     pub fn write(&mut self, s: &str) {
         self.buf.push_str(s);
     }
+
     pub fn into_string(self) -> String {
         self.buf
     }
+
     pub fn write_quoted(&mut self, s: &str) {
         let mut has_newline = false;
         let mut has_nonprintable = false;
@@ -105,7 +114,7 @@ impl<'a> Formatter<'a> {
             self.endline();
             self.indent += self.style.indent;
             for line in s.lines() {
-                if line.trim().len() != 0 {
+                if !line.trim().is_empty() {
                     self.indent();
                     self.write(&line.replace(r#"""""#, r#"\""""#));
                 }
diff --git a/src/helpers.rs b/src/helpers.rs
@@ -8,18 +8,18 @@ use tokenizer::{TokenStream, Kind, Token};
 use position::Pos;
 
 
-#[derive(Clone)]
+#[derive(Debug, Clone)]
 pub struct TokenMatch<'a> {
     kind: Kind,
     phantom: PhantomData<&'a u8>,
 }
 
-#[derive(Clone)]
+#[derive(Debug, Clone)]
 pub struct NameMatch<'a> {
     phantom: PhantomData<&'a u8>,
 }
 
-#[derive(Clone)]
+#[derive(Debug, Clone)]
 pub struct Value<'a> {
     kind: Kind,
     value: &'static str,
@@ -89,6 +89,7 @@ impl<'a> Parser for Value<'a> {
             c.kind == self.kind && c.value == self.value
         }).parse_lazy(input)
     }
+
     fn add_error(&mut self,
         error: &mut Tracked<<Self::Input as StreamOnce>::Error>)
     {
diff --git a/src/query_format.rs b/src/query_format.rs
@@ -87,7 +87,7 @@ impl Displayable for Selection {
 }
 
 fn format_arguments(arguments: &[(String, Value)], f: &mut Formatter) {
-    if arguments.len() > 0 {
+    if !arguments.is_empty() {
         f.write("(");
         f.write(&arguments[0].0);
         f.write(": ");
@@ -112,7 +112,7 @@ impl Displayable for Field {
         f.write(&self.name);
         format_arguments(&self.arguments, f);
         format_directives(&self.directives, f);
-        if self.selection_set.items.len() > 0 {
+        if !self.selection_set.items.is_empty() {
             f.write(" ");
             f.start_block();
             for item in &self.selection_set.items {
@@ -133,7 +133,7 @@ impl Displayable for Query {
         if let Some(ref name) = self.name {
             f.write(" ");
             f.write(name);
-            if self.variable_definitions.len() > 0 {
+            if !self.variable_definitions.is_empty() {
                 f.write("(");
                 self.variable_definitions[0].display(f);
                 for var in &self.variable_definitions[1..] {
@@ -161,7 +161,7 @@ impl Displayable for Mutation {
         if let Some(ref name) = self.name {
             f.write(" ");
             f.write(name);
-            if self.variable_definitions.len() > 0 {
+            if !self.variable_definitions.is_empty() {
                 f.write("(");
                 for var in &self.variable_definitions {
                     var.display(f);
@@ -187,7 +187,7 @@ impl Displayable for Subscription {
         if let Some(ref name) = self.name {
             f.write(" ");
             f.write(name);
-            if self.variable_definitions.len() > 0 {
+            if !self.variable_definitions.is_empty() {
                 f.write("(");
                 for var in &self.variable_definitions {
                     var.display(f);
@@ -248,7 +248,7 @@ impl Displayable for Value {
             Value::Enum(ref name) => f.write(name),
             Value::List(ref items) => {
                 f.write("[");
-                if items.len() > 0 {
+                if !items.is_empty() {
                     items[0].display(f);
                     for item in &items[1..] {
                         f.write(", ");
@@ -330,88 +330,33 @@ impl Displayable for Directive {
     }
 }
 
-impl fmt::Display for Document {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.write_str(&to_string(self))
-    }
-}
-impl fmt::Display for Definition {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.write_str(&to_string(self))
-    }
-}
-impl fmt::Display for OperationDefinition {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.write_str(&to_string(self))
-    }
-}
-impl fmt::Display for FragmentDefinition {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.write_str(&to_string(self))
-    }
-}
-impl fmt::Display for SelectionSet {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.write_str(&to_string(self))
-    }
-}
-impl fmt::Display for Selection {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.write_str(&to_string(self))
-    }
-}
-impl fmt::Display for Field {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.write_str(&to_string(self))
-    }
-}
-impl fmt::Display for Query {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.write_str(&to_string(self))
-    }
-}
-impl fmt::Display for Mutation {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.write_str(&to_string(self))
-    }
-}
-impl fmt::Display for Subscription {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.write_str(&to_string(self))
-    }
-}
-impl fmt::Display for VariableDefinition {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.write_str(&to_string(self))
-    }
-}
-impl fmt::Display for VariableType {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.write_str(&to_string(self))
-    }
-}
-impl fmt::Display for Value {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.write_str(&to_string(self))
-    }
-}
-impl fmt::Display for InlineFragment {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.write_str(&to_string(self))
-    }
-}
-impl fmt::Display for TypeCondition {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.write_str(&to_string(self))
-    }
-}
-impl fmt::Display for FragmentSpread {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.write_str(&to_string(self))
-    }
-}
-impl fmt::Display for Directive {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.write_str(&to_string(self))
-    }
-}
+macro_rules! impl_display {
+    ($( $typ: ident ),+) => {
+        $(
+            impl fmt::Display for $typ {
+                fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+                    f.write_str(&to_string(self))
+                }
+            }
+        )+
+    };
+}
+impl_display!(
+    Document,
+    Definition,
+    OperationDefinition,
+    FragmentDefinition,
+    SelectionSet,
+    Field,
+    Query,
+    Mutation,
+    Subscription,
+    VariableDefinition,
+    VariableType,
+    Value,
+    InlineFragment,
+    TypeCondition,
+    FragmentSpread,
+    Directive
+);
+
diff --git a/src/query_grammar.rs b/src/query_grammar.rs
@@ -112,10 +112,13 @@ pub fn variable_type<'a>(input: &mut TokenStream<'a>)
         .map(Box::new)
         .map(VariableType::ListType))
     .and(optional(punct("!")).map(|v| v.is_some()))
-    .map(|(typ, strict)| match strict {
-        true => VariableType::NonNullType(Box::new(typ)),
-        false => typ,
-    })
+    .map(|(typ, strict)|
+        if strict {
+            VariableType::NonNullType(Box::new(typ))
+        } else {
+            typ
+        }
+    )
     .parse_stream(input)
 }
 
@@ -137,7 +140,7 @@ pub fn float_value<'a>(input: &mut TokenStream<'a>)
 
 fn unquote_string(s: &str) -> Result<String, Error<Token, Token>> {
     let mut res = String::with_capacity(s.len());
-    debug_assert!(s.starts_with("\"") && s.ends_with("\""));
+    debug_assert!(s.starts_with('"') && s.ends_with('"'));
     let mut chars = s[1..s.len()-1].chars();
     while let Some(c) = chars.next() {
         match c {
@@ -161,7 +164,8 @@ fn unquote_string(s: &str) -> Result<String, Error<Token, Token>> {
             c => res.push(c),
         }
     }
-    return Ok(res);
+
+    Ok(res)
 }
 
 fn unquote_block_string(src: &str) -> Result<String, Error<Token, Token>> {
@@ -180,7 +184,7 @@ fn unquote_block_string(src: &str) -> Result<String, Error<Token, Token>> {
     let mut lines = src[3..src.len()-3].lines();
     if let Some(first) = lines.next() {
         let stripped = first.trim();
-        if stripped.len() > 0 {
+        if !stripped.is_empty() {
             result.push_str(stripped);
             result.push('\n');
         }
@@ -193,10 +197,11 @@ fn unquote_block_string(src: &str) -> Result<String, Error<Token, Token>> {
         }
         result.push('\n');
     }
-    if result[last_line..].trim().len() == 0 {
+    if result[last_line..].trim().is_empty() {
         result.truncate(last_line);
     }
-    return Ok(result);
+
+    Ok(result)
 }
 
 pub fn string_value<'a>(input: &mut TokenStream<'a>)
@@ -269,11 +274,16 @@ pub fn query<'a>(input: &mut TokenStream<'a>)
     .parse_stream(input)
 }
 
+/// A set of attributes common to a Query and a Mutation
+type OperationCommon = (
+    Option<String>,
+    Vec<VariableDefinition>,
+    Vec<Directive>,
+    SelectionSet,
+);
+
 pub fn operation_common<'a>(input: &mut TokenStream<'a>)
-    -> ParseResult<
-        (Option<String>, Vec<VariableDefinition>, Vec<Directive>,
-         SelectionSet),
-        TokenStream<'a>>
+    -> ParseResult<OperationCommon, TokenStream<'a>>
 {
     optional(name())
     .and(optional(
@@ -368,6 +378,7 @@ pub fn parse_query(s: &str) -> Result<Document, QueryParseError> {
         .skip(eof())
         .parse_stream(&mut tokens)
         .map_err(|e| e.into_inner().error)?;
+
     Ok(doc)
 }
 
diff --git a/src/tokenizer.rs b/src/tokenizer.rs

Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,7 @@`
`1`	`1`	`//! Formatting graphql`
`2`	`2`	`use std::default::Default;`
`3`	`3`
	`4`	`+#[derive(Debug, PartialEq)]`
`4`	`5`	`pub(crate) struct Formatter<'a> {`
`5`	`6`	`buf: String,`
`6`	`7`	`style: &'a Style,`
`@@ -44,37 +45,45 @@ impl<'a> Formatter<'a> {`
`44`	`45`	`indent: 0,`
`45`	`46`	`}`
`46`	`47`	`}`
	`48`	`+`
`47`	`49`	`pub fn indent(&mut self) {`
`48`	`50`	`for _ in 0..self.indent {`
`49`	`51`	`self.buf.push(' ');`
`50`	`52`	`}`
`51`	`53`	`}`
	`54`	`+`
`52`	`55`	`pub fn endline(&mut self) {`
`53`	`56`	`self.buf.push('\n');`
`54`	`57`	`}`
	`58`	`+`
`55`	`59`	`pub fn start_block(&mut self) {`
`56`	`60`	`self.buf.push('{');`
`57`	`61`	`self.endline();`
`58`	`62`	`self.indent += self.style.indent;`
`59`	`63`	`}`
	`64`	`+`
`60`	`65`	`pub fn end_block(&mut self) {`
`61`	`66`	`self.indent = self.indent.checked_sub(self.style.indent)`
`62`	`67`	`.expect("negative indent");`
`63`	`68`	`self.indent();`
`64`	`69`	`self.buf.push('}');`
`65`	`70`	`self.endline();`
`66`	`71`	`}`
	`72`	`+`
`67`	`73`	`pub fn margin(&mut self) {`
`68`		`- if self.buf.len() != 0 {`
	`74`	`+ if !self.buf.is_empty() {`
`69`	`75`	`self.buf.push('\n');`
`70`	`76`	`}`
`71`	`77`	`}`
	`78`	`+`
`72`	`79`	`pub fn write(&mut self, s: &str) {`
`73`	`80`	`self.buf.push_str(s);`
`74`	`81`	`}`
	`82`	`+`
`75`	`83`	`pub fn into_string(self) -> String {`
`76`	`84`	`self.buf`
`77`	`85`	`}`
	`86`	`+`
`78`	`87`	`pub fn write_quoted(&mut self, s: &str) {`
`79`	`88`	`let mut has_newline = false;`
`80`	`89`	`let mut has_nonprintable = false;`
`@@ -105,7 +114,7 @@ impl<'a> Formatter<'a> {`
`105`	`114`	`self.endline();`
`106`	`115`	`self.indent += self.style.indent;`
`107`	`116`	`for line in s.lines() {`
`108`		`- if line.trim().len() != 0 {`
	`117`	`+ if !line.trim().is_empty() {`
`109`	`118`	`self.indent();`
`110`	`119`	`self.write(&line.replace(r#"""""#, r#"\""""#));`
`111`	`120`	`}`