asya/toml-rs
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

Merge pull request #157 from neosilky/clippy-fixes

Browse source 
Fix issues indicated by clippy
This commit is contained in:
Alex Crichton 2017-04-12 09:13:50 -05:00 committed by GitHub
parent a87d005cc1 469e9f6bd2
commit 8683f1d22b
5 changed files with 25 additions and 26 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

7
src/datetime.rs
View file

@ -179,11 +179,10 @@ impl FromStr for Datetime {
chars.clone().next() == Some('T') { chars.clone().next() == Some('T') {
chars.next(); chars.next();
true true
} else if full_date.is_none() {
true
} else { } else {
false full_date.is_none()
}; };
let time = if partial_time { let time = if partial_time {
let h1 = digit(&mut chars)?; let h1 = digit(&mut chars)?;
let h2 = digit(&mut chars)?; let h2 = digit(&mut chars)?;
@ -299,7 +298,7 @@ impl FromStr for Datetime {
fn digit(chars: &mut str::Chars) -> Result<u8, DatetimeParseError> { fn digit(chars: &mut str::Chars) -> Result<u8, DatetimeParseError> {
match chars.next() { match chars.next() {
Some(c) if '0' <= c && c <= '9' => Ok(c as u8 - '0' as u8), Some(c) if '0' <= c && c <= '9' => Ok(c as u8 - b'0'),
_ => Err(DatetimeParseError { _private: () }), _ => Err(DatetimeParseError { _private: () }),
} }
} }

26
src/de.rs
View file

@ -38,7 +38,7 @@ pub fn from_str<T>(s: &str) -> Result<T, Error>
let mut d = Deserializer::new(s); let mut d = Deserializer::new(s);
let ret = T::deserialize(&mut d)?; let ret = T::deserialize(&mut d)?;
d.end()?; d.end()?;
return Ok(ret) Ok(ret)
} }
/// Errors that can occur when deserializing a type. /// Errors that can occur when deserializing a type.
@ -148,7 +148,7 @@ impl<'a, 'b> de::Deserializer for &'b mut Deserializer<'a> {
while let Some(line) = self.line()? { while let Some(line) = self.line()? {
match line { match line {
Line::Table { at, mut header, array } => { Line::Table { at, mut header, array } => {
if cur_table.header.len() > 0 || cur_table.values.is_some() { if !cur_table.header.is_empty() || cur_table.values.is_some() {
tables.push(cur_table); tables.push(cur_table);
} }
cur_table = Table { cur_table = Table {
@ -175,7 +175,7 @@ impl<'a, 'b> de::Deserializer for &'b mut Deserializer<'a> {
} }
} }
} }
if cur_table.header.len() > 0 || cur_table.values.is_some() { if !cur_table.header.is_empty() || cur_table.values.is_some() {
tables.push(cur_table); tables.push(cur_table);
} }
@ -357,7 +357,7 @@ impl<'a, 'b> de::SeqVisitor for MapVisitor<'a, 'b> {
de: &mut self.de, de: &mut self.de,
})?; })?;
self.cur_parent = next; self.cur_parent = next;
return Ok(Some(ret)) Ok(Some(ret))
} }
} }
@ -470,7 +470,7 @@ impl<'a> de::Deserializer for ValueDeserializer<'a> {
where V: de::Visitor, where V: de::Visitor,
{ {
if name == SERDE_STRUCT_NAME && fields == &[SERDE_STRUCT_FIELD_NAME] { if name == SERDE_STRUCT_NAME && fields == &[SERDE_STRUCT_FIELD_NAME] {
if let Value::Datetime(ref s) = self.value { if let Value::Datetime(s) = self.value {
return visitor.visit_map(DatetimeDeserializer { return visitor.visit_map(DatetimeDeserializer {
date: s, date: s,
visited: false, visited: false,
@ -687,7 +687,7 @@ impl<'a> Deserializer<'a> {
} }
fn number_or_date(&mut self, s: &'a str) -> Result<Value<'a>, Error> { fn number_or_date(&mut self, s: &'a str) -> Result<Value<'a>, Error> {
if s.contains("T") || (s.len() > 1 && s[1..].contains("-")) && if s.contains('T') || (s.len() > 1 && s[1..].contains('-')) &&
!s.contains("e-") { !s.contains("e-") {
self.datetime(s, false).map(Value::Datetime) self.datetime(s, false).map(Value::Datetime)
} else if self.eat(Token::Colon)? { } else if self.eat(Token::Colon)? {
@ -698,7 +698,7 @@ impl<'a> Deserializer<'a> {
} }
fn number(&mut self, s: &'a str) -> Result<Value<'a>, Error> { fn number(&mut self, s: &'a str) -> Result<Value<'a>, Error> {
if s.contains("e") || s.contains("E") { if s.contains('e') || s.contains('E') {
self.float(s, None).map(Value::Float) self.float(s, None).map(Value::Float)
} else if self.eat(Token::Period)? { } else if self.eat(Token::Period)? {
let at = self.tokens.current(); let at = self.tokens.current();
@ -727,7 +727,7 @@ impl<'a> Deserializer<'a> {
if suffix != "" { if suffix != "" {
return Err(self.error(start, ErrorKind::NumberInvalid)) return Err(self.error(start, ErrorKind::NumberInvalid))
} }
prefix.replace("_", "").trim_left_matches("+").parse().map_err(|_e| { prefix.replace("_", "").trim_left_matches('+').parse().map_err(|_e| {
self.error(start, ErrorKind::NumberInvalid) self.error(start, ErrorKind::NumberInvalid)
}) })
} }
@ -783,13 +783,13 @@ impl<'a> Deserializer<'a> {
if suffix != "" { if suffix != "" {
return Err(self.error(start, ErrorKind::NumberInvalid)) return Err(self.error(start, ErrorKind::NumberInvalid))
} }
let (a, b) = self.parse_integer(&after, false, true)?; let (a, b) = self.parse_integer(after, false, true)?;
fraction = Some(a); fraction = Some(a);
suffix = b; suffix = b;
} }
let mut exponent = None; let mut exponent = None;
if suffix.starts_with("e") || suffix.starts_with("E") { if suffix.starts_with('e') || suffix.starts_with('E') {
let (a, b) = if suffix.len() == 1 { let (a, b) = if suffix.len() == 1 {
self.eat(Token::Plus)?; self.eat(Token::Plus)?;
match self.next()? { match self.next()? {
@ -807,7 +807,7 @@ impl<'a> Deserializer<'a> {
exponent = Some(a); exponent = Some(a);
} }
let mut number = integral.trim_left_matches("+") let mut number = integral.trim_left_matches('+')
.chars() .chars()
.filter(|c| *c != '_') .filter(|c| *c != '_')
.collect::<String>(); .collect::<String>();
@ -1003,7 +1003,7 @@ impl<'a> Deserializer<'a> {
let (line, col) = self.to_linecol(at); let (line, col) = self.to_linecol(at);
err.inner.line = Some(line); err.inner.line = Some(line);
err.inner.col = col; err.inner.col = col;
return err err
} }
/// Converts a byte offset from an error message to a (line, column) pair /// Converts a byte offset from an error message to a (line, column) pair
@ -1095,7 +1095,7 @@ impl fmt::Display for Error {
ErrorKind::__Nonexhaustive => panic!(), ErrorKind::__Nonexhaustive => panic!(),
} }
if self.inner.key.len() > 0 { if !self.inner.key.is_empty() {
write!(f, " for key `")?; write!(f, " for key `")?;
for (i, k) in self.inner.key.iter().enumerate() { for (i, k) in self.inner.key.iter().enumerate() {
if i > 0 { if i > 0 {

10
src/ser.rs
View file

@ -283,7 +283,7 @@ impl<'a> Serializer<'a> {
if array_of_tables { if array_of_tables {
self.dst.push_str("["); self.dst.push_str("[");
} }
self.emit_key_part(&state)?; self.emit_key_part(state)?;
if array_of_tables { if array_of_tables {
self.dst.push_str("]"); self.dst.push_str("]");
} }
@ -563,7 +563,7 @@ impl<'a, 'b> ser::SerializeMap for SerializeTable<'a, 'b> {
SerializeTable::Table { ref mut key, .. } => { SerializeTable::Table { ref mut key, .. } => {
key.truncate(0); key.truncate(0);
*key = input.serialize(StringExtractor)?; *key = input.serialize(StringExtractor)?;
if key.contains("\n") { if key.contains('\n') {
return Err(Error::KeyNewline) return Err(Error::KeyNewline)
} }
} }
@ -586,10 +586,10 @@ impl<'a, 'b> ser::SerializeMap for SerializeTable<'a, 'b> {
let res = value.serialize(&mut Serializer { let res = value.serialize(&mut Serializer {
dst: &mut *ser.dst, dst: &mut *ser.dst,
state: State::Table { state: State::Table {
key: &key, key: key,
parent: &ser.state, parent: &ser.state,
first: &first, first: first,
table_emitted: &table_emitted, table_emitted: table_emitted,
}, },
}); });
match res { match res {

6
src/tokens.rs
View file

@ -66,7 +66,7 @@ impl<'a> Tokenizer<'a> {
}; };
// Eat utf-8 BOM // Eat utf-8 BOM
t.eatc('\u{feff}'); t.eatc('\u{feff}');
return t t
} }
pub fn next(&mut self) -> Result<Option<Token<'a>>, Error> { pub fn next(&mut self) -> Result<Option<Token<'a>>, Error> {
@ -141,7 +141,7 @@ impl<'a> Tokenizer<'a> {
if val == "" { if val == "" {
return Err(Error::EmptyTableKey(offset)) return Err(Error::EmptyTableKey(offset))
} }
match src.find("\n") { match src.find('\n') {
None => Ok(val), None => Ok(val),
Some(i) => Err(Error::NewlineInTableKey(offset + i)), Some(i) => Err(Error::NewlineInTableKey(offset + i)),
} }
@ -422,7 +422,7 @@ impl MaybeString {
} }
} }
fn into_cow<'a>(self, input: &'a str) -> Cow<'a, str> { fn into_cow(self, input: &str) -> Cow<str> {
match self { match self {
MaybeString::NotEscaped(start) => Cow::Borrowed(&input[start..]), MaybeString::NotEscaped(start) => Cow::Borrowed(&input[start..]),
MaybeString::Owned(s) => Cow::Owned(s), MaybeString::Owned(s) => Cow::Owned(s),

2
tests/valid.rs
View file

@ -18,7 +18,7 @@ fn to_json(toml: toml::Value) -> Json {
Toml::Float(f) => doit("float", Json::String({ Toml::Float(f) => doit("float", Json::String({
let s = format!("{:.15}", f); let s = format!("{:.15}", f);
let s = format!("{}", s.trim_right_matches('0')); let s = format!("{}", s.trim_right_matches('0'));
if s.ends_with(".") {format!("{}0", s)} else {s} if s.ends_with('.') {format!("{}0", s)} else {s}
})), })),
Toml::Boolean(b) => doit("bool", Json::String(format!("{}", b))), Toml::Boolean(b) => doit("bool", Json::String(format!("{}", b))),
Toml::Datetime(s) => doit("datetime", Json::String(s.to_string())), Toml::Datetime(s) => doit("datetime", Json::String(s.to_string())),