Skip to content

Commit 8049282

Browse files
ashfordneilMichael Eden
ashfordneil
authored and
Michael Eden
committed
Use the ? operator (#124)
* removed try! * no longer cache `rustfmt` binary on travis
1 parent a802151 commit 8049282

File tree

16 files changed

+108
-121
lines changed

16 files changed

+108
-121
lines changed

‎.travis.yml‎

Lines changed: 0 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,5 @@
11
language: rust
22
rust: nightly
3-
cache: cargo
43
before_script:
54
- export PATH="$PATH:$HOME/.cargo/bin"
65
- which rustfmt || cargo install rustfmt

‎examples/autobahn-client.rs‎

Lines changed: 1 addition & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -82,8 +82,7 @@ fn get_case_count(addr: String) -> usize {
8282
Ok(message) => message,
8383
Err(e) => {
8484
println!("Error: {:?}", e);
85-
let _ =
86-
sender.send_message(&Message::close_because(1002, "".to_string()));
85+
let _ = sender.send_message(&Message::close_because(1002, "".to_string()));
8786
break;
8887
}
8988
};

‎src/client/builder.rs‎

Lines changed: 38 additions & 41 deletions
Original file line numberDiff line numberDiff line change
@@ -142,7 +142,7 @@ impl<'u> ClientBuilder<'u> {
142142
/// let builder = ClientBuilder::new("wss://mycluster.club");
143143
/// ```
144144
pub fn new(address: &str) -> Result<Self, ParseError> {
145-
let url = try!(Url::parse(address));
145+
let url = Url::parse(address)?;
146146
Ok(ClientBuilder::init(Cow::Owned(url)))
147147
}
148148

@@ -390,11 +390,11 @@ impl<'u> ClientBuilder<'u> {
390390
&mut self,
391391
ssl_config: Option<TlsConnector>,
392392
) -> WebSocketResult<Client<Box<NetworkStream + Send>>> {
393-
let tcp_stream = try!(self.establish_tcp(None));
393+
let tcp_stream = self.establish_tcp(None)?;
394394

395395
let boxed_stream: Box<NetworkStream + Send> = if
396396
self.url.scheme() == "wss" {
397-
Box::new(try!(self.wrap_ssl(tcp_stream, ssl_config)))
397+
Box::new(self.wrap_ssl(tcp_stream, ssl_config)?)
398398
} else {
399399
Box::new(tcp_stream)
400400
};
@@ -418,7 +418,7 @@ impl<'u> ClientBuilder<'u> {
418418
/// ```
419419
#[cfg(feature="sync")]
420420
pub fn connect_insecure(&mut self) -> WebSocketResult<Client<TcpStream>> {
421-
let tcp_stream = try!(self.establish_tcp(Some(false)));
421+
let tcp_stream = self.establish_tcp(Some(false))?;
422422

423423
self.connect_on(tcp_stream)
424424
}
@@ -432,9 +432,9 @@ impl<'u> ClientBuilder<'u> {
432432
&mut self,
433433
ssl_config: Option<TlsConnector>,
434434
) -> WebSocketResult<Client<TlsStream<TcpStream>>> {
435-
let tcp_stream = try!(self.establish_tcp(Some(true)));
435+
let tcp_stream = self.establish_tcp(Some(true))?;
436436

437-
let ssl_stream = try!(self.wrap_ssl(tcp_stream, ssl_config));
437+
let ssl_stream = self.wrap_ssl(tcp_stream, ssl_config)?;
438438

439439
self.connect_on(ssl_stream)
440440
}
@@ -474,12 +474,12 @@ impl<'u> ClientBuilder<'u> {
474474
{
475475
// send request
476476
let resource = self.build_request();
477-
try!(write!(stream, "GET {} {}\r\n", resource, self.version));
478-
try!(write!(stream, "{}\r\n", self.headers));
477+
write!(stream, "GET {} {}\r\n", resource, self.version)?;
478+
write!(stream, "{}\r\n", self.headers)?;
479479

480480
// wait for a response
481481
let mut reader = BufReader::new(stream);
482-
let response = try!(parse_response(&mut reader));
482+
let response = parse_response(&mut reader)?;
483483

484484
// validate
485485
self.validate(&response)?;
@@ -561,25 +561,23 @@ impl<'u> ClientBuilder<'u> {
561561
}
562562
};
563563
// secure connection, wrap with ssl
564-
let future =
565-
tcp_stream.map_err(|e| e.into())
566-
.and_then(move |s| {
567-
connector.connect_async(&host, s)
568-
.map_err(|e| e.into())
569-
})
570-
.and_then(move |stream| {
571-
let stream: Box<stream::async::Stream + Send> = Box::new(stream);
572-
builder.async_connect_on(stream)
573-
});
564+
let future = tcp_stream.map_err(|e| e.into())
565+
.and_then(move |s| {
566+
connector.connect_async(&host, s)
567+
.map_err(|e| e.into())
568+
})
569+
.and_then(move |stream| {
570+
let stream: Box<stream::async::Stream + Send> = Box::new(stream);
571+
builder.async_connect_on(stream)
572+
});
574573
Box::new(future)
575574
} else {
576575
// insecure connection, connect normally
577-
let future =
578-
tcp_stream.map_err(|e| e.into())
579-
.and_then(move |stream| {
580-
let stream: Box<stream::async::Stream + Send> = Box::new(stream);
581-
builder.async_connect_on(stream)
582-
});
576+
let future = tcp_stream.map_err(|e| e.into())
577+
.and_then(move |stream| {
578+
let stream: Box<stream::async::Stream + Send> = Box::new(stream);
579+
builder.async_connect_on(stream)
580+
});
583581
Box::new(future)
584582
}
585583
}
@@ -648,14 +646,13 @@ impl<'u> ClientBuilder<'u> {
648646
};
649647

650648
// put it all together
651-
let future = tcp_stream.map_err(|e| e.into())
652-
.and_then(move |s| {
653-
connector.connect_async(&host, s)
654-
.map_err(|e| e.into())
655-
})
656-
.and_then(move |stream| {
657-
builder.async_connect_on(stream)
658-
});
649+
let future =
650+
tcp_stream.map_err(|e| e.into())
651+
.and_then(move |s| {
652+
connector.connect_async(&host, s)
653+
.map_err(|e| e.into())
654+
})
655+
.and_then(move |stream| builder.async_connect_on(stream));
659656
Box::new(future)
660657
}
661658

@@ -707,10 +704,9 @@ impl<'u> ClientBuilder<'u> {
707704
key_set: self.key_set,
708705
};
709706

710-
let future = tcp_stream.map_err(|e| e.into())
711-
.and_then(move |stream| {
712-
builder.async_connect_on(stream)
713-
});
707+
let future =
708+
tcp_stream.map_err(|e| e.into())
709+
.and_then(move |stream| builder.async_connect_on(stream));
714710
Box::new(future)
715711
}
716712

@@ -868,9 +864,10 @@ impl<'u> ClientBuilder<'u> {
868864
return Err(WebSocketError::ResponseError("Status code must be Switching Protocols"));
869865
}
870866

871-
let key = try!(self.headers
872-
.get::<WebSocketKey>()
873-
.ok_or(WebSocketError::RequestError("Request Sec-WebSocket-Key was invalid")));
867+
let key =
868+
self.headers
869+
.get::<WebSocketKey>()
870+
.ok_or(WebSocketError::RequestError("Request Sec-WebSocket-Key was invalid"))?;
874871

875872
if response.headers.get() != Some(&(WebSocketAccept::new(key))) {
876873
return Err(WebSocketError::ResponseError("Sec-WebSocket-Accept is invalid"));
@@ -941,7 +938,7 @@ impl<'u> ClientBuilder<'u> {
941938
connector: Option<TlsConnector>,
942939
) -> WebSocketResult<TlsStream<TcpStream>> {
943940
let (host, connector) = self.extract_host_ssl_conn(connector)?;
944-
let ssl_stream = try!(connector.connect(host, tcp_stream));
941+
let ssl_stream = connector.connect(host, tcp_stream)?;
945942
Ok(ssl_stream)
946943
}
947944
}

‎src/client/sync.rs‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -361,10 +361,10 @@ impl<S> Client<S>
361361
///# }
362362
///```
363363
pub fn split
364-
(self,)
364+
(self)
365365
-> IoResult<(Reader<<S as Splittable>::Reader>, Writer<<S as Splittable>::Writer>)> {
366366
let (stream, buf, pos, cap) = self.stream.into_parts();
367-
let (read, write) = try!(stream.split());
367+
let (read, write) = stream.split()?;
368368
Ok((Reader {
369369
stream: BufReader::from_parts(read, buf, pos, cap),
370370
receiver: self.receiver,

‎src/codec/ws.rs‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -245,7 +245,7 @@ impl<M> Decoder for MessageCodec<M>
245245
match frame.opcode as u8 {
246246
// continuation code
247247
0 if is_first => {
248-
return Err(WebSocketError::ProtocolError("Unexpected continuation data frame opcode"));
248+
return Err(WebSocketError::ProtocolError("Unexpected continuation data frame opcode",),);
249249
}
250250
// control frame
251251
8...15 => {

‎src/dataframe.rs‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -83,7 +83,7 @@ impl DataFrame {
8383
pub fn read_dataframe<R>(reader: &mut R, should_be_masked: bool) -> WebSocketResult<Self>
8484
where R: Read
8585
{
86-
let header = try!(dfh::read_header(reader));
86+
let header = dfh::read_header(reader)?;
8787

8888
let mut data: Vec<u8> = Vec::with_capacity(header.len as usize);
8989
let read = reader.take(header.len).read_to_end(&mut data)?;

‎src/header/accept.rs‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -27,7 +27,7 @@ impl FromStr for WebSocketAccept {
2727
match base64::decode(accept) {
2828
Ok(vec) => {
2929
if vec.len() != 20 {
30-
return Err(WebSocketError::ProtocolError("Sec-WebSocket-Accept must be 20 bytes"));
30+
return Err(WebSocketError::ProtocolError("Sec-WebSocket-Accept must be 20 bytes",),);
3131
}
3232
let mut array = [0u8; 20];
3333
let mut iter = vec.into_iter();

‎src/header/extensions.rs‎

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -68,9 +68,9 @@ impl FromStr for Extension {
6868

6969
impl fmt::Display for Extension {
7070
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
71-
try!(write!(f, "{}", self.name));
71+
write!(f, "{}", self.name)?;
7272
for param in &self.params {
73-
try!(write!(f, "; {}", param));
73+
write!(f, "; {}", param)?;
7474
}
7575
Ok(())
7676
}
@@ -97,9 +97,9 @@ impl Parameter {
9797

9898
impl fmt::Display for Parameter {
9999
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
100-
try!(write!(f, "{}", self.name));
100+
write!(f, "{}", self.name)?;
101101
if let Some(ref x) = self.value {
102-
try!(write!(f, "={}", x));
102+
write!(f, "={}", x)?;
103103
}
104104
Ok(())
105105
}

‎src/message.rs‎

Lines changed: 28 additions & 36 deletions
Original file line numberDiff line numberDiff line change
@@ -59,12 +59,10 @@ impl<'a> Message<'a> {
5959
pub fn text<S>(data: S) -> Self
6060
where S: Into<Cow<'a, str>>
6161
{
62-
Message::new(Type::Text,
63-
None,
64-
match data.into() {
65-
Cow::Owned(msg) => Cow::Owned(msg.into_bytes()),
66-
Cow::Borrowed(msg) => Cow::Borrowed(msg.as_bytes()),
67-
})
62+
Message::new(Type::Text, None, match data.into() {
63+
Cow::Owned(msg) => Cow::Owned(msg.into_bytes()),
64+
Cow::Borrowed(msg) => Cow::Borrowed(msg.as_bytes()),
65+
})
6866
}
6967

7068
/// Create a new WebSocket message with binary data
@@ -86,12 +84,10 @@ impl<'a> Message<'a> {
8684
pub fn close_because<S>(code: u16, reason: S) -> Self
8785
where S: Into<Cow<'a, str>>
8886
{
89-
Message::new(Type::Close,
90-
Some(code),
91-
match reason.into() {
92-
Cow::Owned(msg) => Cow::Owned(msg.into_bytes()),
93-
Cow::Borrowed(msg) => Cow::Borrowed(msg.as_bytes()),
94-
})
87+
Message::new(Type::Close, Some(code), match reason.into() {
88+
Cow::Owned(msg) => Cow::Owned(msg.into_bytes()),
89+
Cow::Borrowed(msg) => Cow::Borrowed(msg.as_bytes()),
90+
})
9591
}
9692

9793
/// Create a ping WebSocket message, a pong is usually sent back
@@ -144,9 +140,9 @@ impl<'a> ws::dataframe::DataFrame for Message<'a> {
144140

145141
fn write_payload(&self, socket: &mut Write) -> WebSocketResult<()> {
146142
if let Some(reason) = self.cd_status_code {
147-
try!(socket.write_u16::<BigEndian>(reason));
143+
socket.write_u16::<BigEndian>(reason)?;
148144
}
149-
try!(socket.write_all(&*self.payload));
145+
socket.write_all(&*self.payload)?;
150146
Ok(())
151147
}
152148

@@ -178,9 +174,9 @@ impl<'a> ws::Message for Message<'a> {
178174
fn from_dataframes<D>(frames: Vec<D>) -> WebSocketResult<Self>
179175
where D: DataFrameTrait
180176
{
181-
let opcode = try!(frames.first()
182-
.ok_or(WebSocketError::ProtocolError("No dataframes provided"))
183-
.map(|d| d.opcode()));
177+
let opcode = frames.first()
178+
.ok_or(WebSocketError::ProtocolError("No dataframes provided",),)
179+
.map(|d| d.opcode())?;
184180
let opcode = Opcode::new(opcode);
185181

186182
let payload_size = frames.iter().map(|d| d.size()).sum();
@@ -214,8 +210,8 @@ impl<'a> ws::Message for Message<'a> {
214210
Some(Opcode::Binary) => Message::binary(data),
215211
Some(Opcode::Close) => {
216212
if data.len() > 0 {
217-
let status_code = try!((&data[..]).read_u16::<BigEndian>());
218-
let reason = try!(bytes_to_string(&data[2..]));
213+
let status_code = (&data[..]).read_u16::<BigEndian>()?;
214+
let reason = bytes_to_string(&data[2..])?;
219215
Message::close_because(status_code, reason)
220216
} else {
221217
Message::close()
@@ -387,18 +383,10 @@ impl ws::dataframe::DataFrame for OwnedMessage {
387383

388384
fn write_payload(&self, socket: &mut Write) -> WebSocketResult<()> {
389385
match *self {
390-
OwnedMessage::Text(ref txt) => {
391-
socket.write_all(txt.as_bytes())?
392-
}
393-
OwnedMessage::Binary(ref bin) => {
394-
socket.write_all(bin.as_slice())?
395-
}
396-
OwnedMessage::Ping(ref data) => {
397-
socket.write_all(data.as_slice())?
398-
}
399-
OwnedMessage::Pong(ref data) => {
400-
socket.write_all(data.as_slice())?
401-
}
386+
OwnedMessage::Text(ref txt) => socket.write_all(txt.as_bytes())?,
387+
OwnedMessage::Binary(ref bin) => socket.write_all(bin.as_slice())?,
388+
OwnedMessage::Ping(ref data) => socket.write_all(data.as_slice())?,
389+
OwnedMessage::Pong(ref data) => socket.write_all(data.as_slice())?,
402390
OwnedMessage::Close(ref data) => {
403391
match data {
404392
&Some(ref c) => {
@@ -443,10 +431,14 @@ impl<'m> From<Message<'m>> for OwnedMessage {
443431
}
444432
Type::Close => {
445433
match message.cd_status_code {
446-
Some(code) => OwnedMessage::Close(Some(CloseData {
447-
status_code: code,
448-
reason: String::from_utf8_lossy(&message.payload).into_owned(),
449-
})),
434+
Some(code) => {
435+
OwnedMessage::Close(Some(CloseData {
436+
status_code: code,
437+
reason:
438+
String::from_utf8_lossy(&message.payload)
439+
.into_owned(),
440+
}))
441+
}
450442
None => OwnedMessage::Close(None),
451443
}
452444
}
@@ -494,7 +486,7 @@ impl CloseData {
494486
/// Convert this into a vector of bytes
495487
pub fn into_bytes(self) -> io::Result<Vec<u8>> {
496488
let mut buf = Vec::new();
497-
try!(buf.write_u16::<BigEndian>(self.status_code));
489+
buf.write_u16::<BigEndian>(self.status_code)?;
498490
for i in self.reason.as_bytes().iter() {
499491
buf.push(*i);
500492
}

‎src/receiver.rs‎

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -103,10 +103,10 @@ impl ws::Receiver for Receiver {
103103
where R: Read
104104
{
105105
let mut finished = if self.buffer.is_empty() {
106-
let first = try!(self.recv_dataframe(reader));
106+
let first = self.recv_dataframe(reader)?;
107107

108108
if first.opcode == Opcode::Continuation {
109-
return Err(WebSocketError::ProtocolError("Unexpected continuation data frame opcode"));
109+
return Err(WebSocketError::ProtocolError("Unexpected continuation data frame opcode",),);
110110
}
111111

112112
let finished = first.finished;
@@ -117,7 +117,7 @@ impl ws::Receiver for Receiver {
117117
};
118118

119119
while !finished {
120-
let next = try!(self.recv_dataframe(reader));
120+
let next = self.recv_dataframe(reader)?;
121121
finished = next.finished;
122122

123123
match next.opcode as u8 {

0 commit comments

Comments
 (0)