Expose style, hide and shorten parse error names

Author: tailhook

src/lib.rs

@@ -106,6 +106,7 @@ mod helpers;
 pub mod query;
 pub mod schema;
 
-pub use query::{parse_query, QueryParseError};
-pub use schema::{parse_schema, SchemaParseError};
+pub use query::parse_query;
+pub use schema::parse_schema;
 pub use position::Pos;
+pub use format::Style;

src/query/error.rs

@@ -12,10 +12,10 @@ pub type InternalError<'a> = Errors<Token<'a>, Token<'a>, Pos>;
 /// way to improve both error message and API.
 #[derive(Fail, Debug)]
 #[fail(display="query parse error: {}", _0)]
-pub struct QueryParseError(String);
+pub struct ParseError(String);
 
-impl<'a> From<InternalError<'a>> for QueryParseError {
-    fn from(e: InternalError<'a>) -> QueryParseError {
-        QueryParseError(format!("{}", e))
+impl<'a> From<InternalError<'a>> for ParseError {
+    fn from(e: InternalError<'a>) -> ParseError {
+        ParseError(format!("{}", e))
     }
 }

src/query/grammar.rs

@@ -5,7 +5,7 @@ use common::{Directive};
 use common::{directives, arguments, default_value, parse_type};
 use tokenizer::{TokenStream};
 use helpers::{punct, ident, name};
-use query::error::{QueryParseError};
+use query::error::{ParseError};
 use query::ast::*;
 
 pub fn field<'a>(input: &mut TokenStream<'a>)
@@ -182,7 +182,7 @@ pub fn definition<'a>(input: &mut TokenStream<'a>)
 }
 
 /// Parses a piece of query language and returns an AST
-pub fn parse_query(s: &str) -> Result<Document, QueryParseError> {
+pub fn parse_query(s: &str) -> Result<Document, ParseError> {
     let mut tokens = TokenStream::new(s);
     let (doc, _) = many1(parser(definition))
         .map(|d| Document { definitions: d })

src/query/mod.rs

@@ -7,5 +7,5 @@ mod grammar;
 
 
 pub use self::grammar::parse_query;
-pub use self::error::QueryParseError;
+pub use self::error::ParseError;
 pub use self::ast::*;

src/schema/error.rs

@@ -12,10 +12,10 @@ pub type InternalError<'a> = Errors<Token<'a>, Token<'a>, Pos>;
 /// way to improve both error message and API.
 #[derive(Fail, Debug)]
 #[fail(display="schema parse error: {}", _0)]
-pub struct SchemaParseError(String);
+pub struct ParseError(String);
 
-impl<'a> From<InternalError<'a>> for SchemaParseError {
-    fn from(e: InternalError<'a>) -> SchemaParseError {
-        SchemaParseError(format!("{}", e))
+impl<'a> From<InternalError<'a>> for ParseError {
+    fn from(e: InternalError<'a>) -> ParseError {
+        ParseError(format!("{}", e))
     }
 }

src/schema/grammar.rs

@@ -8,7 +8,7 @@ use failure::Fail;
 use tokenizer::{Kind as T, Token, TokenStream};
 use helpers::{punct, ident, kind, name};
 use common::{directives, string, default_value, parse_type};
-use schema::error::{SchemaParseError};
+use schema::error::{ParseError};
 use schema::ast::*;
 
 
@@ -526,7 +526,7 @@ pub fn definition<'a>(input: &mut TokenStream<'a>)
 }
 
 /// Parses a piece of schema language and returns an AST
-pub fn parse_schema(s: &str) -> Result<Document, SchemaParseError> {
+pub fn parse_schema(s: &str) -> Result<Document, ParseError> {
     let mut tokens = TokenStream::new(s);
     let (doc, _) = many1(parser(definition))
         .map(|d| Document { definitions: d })

src/schema/mod.rs

@@ -6,5 +6,5 @@ mod error;
 mod format;
 
 pub use self::ast::*;
-pub use self::error::SchemaParseError;
+pub use self::error::ParseError;
 pub use self::grammar::parse_schema;