Merge pull request #37 from oherrala/clippy-nags

Fix Clippy nags
Geal · Aug 27, 2018 · f784f91 · f784f91
2 parents af5a427 + 3047fc9
commit f784f91
Show file tree

Hide file tree

Showing 2 changed files with 46 additions and 47 deletions.
diff --git a/src/format.rs b/src/format.rs
@@ -97,12 +97,12 @@ impl Formatter5424 {
       "-".to_string()
     } else {
       let mut res = String::new();
-      for (id, params) in data.iter() {
+      for (id, params) in &data {
         res = res + "["+id;
-        for (name,value) in params.iter() {
+        for (name,value) in params {
           res = res + " " + name + "=\"" + value + "\"";
         }
-        res = res + "]";
+        res += "]";
       }
 
       res
@@ -125,5 +125,5 @@ impl<T: Display> LogFormat<(i32, StructuredData, T)> for Formatter5424 {
 }
 
 fn encode_priority(severity: Severity, facility: Facility) -> Priority {
-  return facility as u8 | severity as u8
+  facility as u8 | severity as u8
 }
diff --git a/src/lib.rs b/src/lib.rs
@@ -113,59 +113,59 @@ pub enum LoggerBackend {
 impl Write for LoggerBackend {
   /// Sends a message directly, without any formatting
   fn write(&mut self, message: &[u8]) -> io::Result<usize> {
-    match self {
-      &mut LoggerBackend::Unix(ref dgram) => {
+    match *self {
+      LoggerBackend::Unix(ref dgram) => {
         dgram.send(&message[..])
       },
-      &mut LoggerBackend::UnixStream(ref mut socket) => {
+      LoggerBackend::UnixStream(ref mut socket) => {
         let null = [0 ; 1];
         socket.write(&message[..]).and_then(|sz| {
           socket.write(&null).map(|_| sz)
         })
       },
-      &mut LoggerBackend::Udp(ref socket, ref addr)    => {
+      LoggerBackend::Udp(ref socket, ref addr)    => {
         socket.send_to(&message[..], addr)
       },
-      &mut LoggerBackend::Tcp(ref mut socket)         => {
+      LoggerBackend::Tcp(ref mut socket)         => {
         socket.write(&message[..])
       }
     }
   }
 
   fn write_fmt(&mut self, args: Arguments) -> io::Result<()>  {
-    match self {
-      &mut LoggerBackend::Unix(ref dgram) => {
+    match *self {
+      LoggerBackend::Unix(ref dgram) => {
         let message = fmt::format(args);
         dgram.send(message.as_bytes()).map(|_| ())
       },
-      &mut LoggerBackend::UnixStream(ref mut socket) => {
+      LoggerBackend::UnixStream(ref mut socket) => {
         let null = [0 ; 1];
         socket.write_fmt(args).and_then(|_| {
           socket.write(&null).map(|_| ())
         })
       },
-      &mut LoggerBackend::Udp(ref socket, ref addr)    => {
+      LoggerBackend::Udp(ref socket, ref addr)    => {
         let message = fmt::format(args);
         socket.send_to(message.as_bytes(), addr).map(|_| ())
       },
-      &mut LoggerBackend::Tcp(ref mut socket)         => {
+      LoggerBackend::Tcp(ref mut socket)         => {
         socket.write_fmt(args)
       }
     }
   }
 
   fn flush(&mut self) -> io::Result<()> {
-    match self {
-      &mut LoggerBackend::Unix(_) => {
+    match *self {
+      LoggerBackend::Unix(_) => {
         Ok(())
       },
-      &mut LoggerBackend::UnixStream(ref mut socket) => {
+      LoggerBackend::UnixStream(ref mut socket) => {
         socket.flush()
       },
-      &mut LoggerBackend::Udp(_, _)  => {
+      LoggerBackend::Udp(_, _)  => {
         Ok(())
       },
-      &mut LoggerBackend::Tcp(ref mut socket)        => {
+      LoggerBackend::Tcp(ref mut socket)        => {
         socket.flush()
       }
     }
@@ -175,7 +175,7 @@ impl Write for LoggerBackend {
 /// Returns a Logger using unix socket to target local syslog ( using /dev/log or /var/run/syslog)
 pub fn unix<U: Display, F: Clone+LogFormat<U>>(formatter: F) -> Result<Logger<LoggerBackend, U, F>> {
     unix_connect(formatter.clone(), "/dev/log").or_else(|e| {
-      if let &ErrorKind::Io(ref io_err) = e.kind() {
+      if let ErrorKind::Io(ref io_err) = *e.kind() {
         if io_err.kind() == io::ErrorKind::NotFound {
           return unix_connect(formatter, "/var/run/syslog");
         }
@@ -195,7 +195,7 @@ fn unix_connect<P: AsRef<Path>, U: Display, F: LogFormat<U>>(formatter: F, path:
     Ok(()) => {
         println!("ok");
         Ok(Logger {
-          formatter: formatter,
+          formatter,
           backend:   LoggerBackend::Unix(sock),
           phantom:   PhantomData,
         })
@@ -204,7 +204,7 @@ fn unix_connect<P: AsRef<Path>, U: Display, F: LogFormat<U>>(formatter: F, path:
         println!("testing stream");
         let sock = UnixStream::connect(path)?;
         Ok(Logger {
-            formatter: formatter,
+            formatter,
             backend:   LoggerBackend::UnixStream(BufWriter::new(sock)),
             phantom:   PhantomData,
         })
@@ -220,7 +220,7 @@ pub fn udp<T: ToSocketAddrs, U: Display, F: LogFormat<U>>(formatter: F, local: T
   }).and_then(|server_addr| {
     UdpSocket::bind(local).chain_err(|| ErrorKind::Initialization).and_then(|socket| {
       Ok(Logger {
-        formatter: formatter,
+        formatter,
         backend:   LoggerBackend::Udp(socket, server_addr),
         phantom:   PhantomData,
       })
@@ -232,7 +232,7 @@ pub fn udp<T: ToSocketAddrs, U: Display, F: LogFormat<U>>(formatter: F, local: T
 pub fn tcp<T: ToSocketAddrs, U: Display, F: LogFormat<U>>(formatter: F, server: T) -> Result<Logger<LoggerBackend, U, F>> {
   TcpStream::connect(server).chain_err(|| ErrorKind::Initialization).and_then(|socket| {
     Ok(Logger {
-      formatter: formatter,
+      formatter,
       backend:   LoggerBackend::Tcp(BufWriter::new(socket)),
       phantom:   PhantomData,
     })
@@ -277,12 +277,12 @@ impl Log for BasicLogger {
 
 /// Unix socket Logger init function compatible with log crate
 pub fn init_unix(facility: Facility, log_level: log::LevelFilter) -> Result<()> {
-  let (process_name, pid) = get_process_info()?;
+  let (process, pid) = get_process_info()?;
   let formatter = Formatter3164 {
-    facility: facility.clone(),
+    facility,
     hostname: None,
-    process:  process_name,
-    pid:      pid,
+    process,
+    pid,
   };
   unix(formatter).and_then(|logger| {
     log::set_boxed_logger(Box::new(BasicLogger::new(logger))
@@ -295,12 +295,12 @@ pub fn init_unix(facility: Facility, log_level: log::LevelFilter) -> Result<()>
 
 /// Unix socket Logger init function compatible with log crate and user provided socket path
 pub fn init_unix_custom<P: AsRef<Path>>(facility: Facility, log_level: log::LevelFilter, path: P) -> Result<()> {
-  let (process_name, pid) = get_process_info()?;
+  let (process, pid) = get_process_info()?;
   let formatter = Formatter3164 {
-    facility: facility.clone(),
+    facility,
     hostname: None,
-    process:  process_name,
-    pid:      pid,
+    process,
+    pid,
   };
   unix_custom(formatter, path).and_then(|logger| {
     log::set_boxed_logger(Box::new(BasicLogger::new(logger)))
@@ -313,12 +313,12 @@ pub fn init_unix_custom<P: AsRef<Path>>(facility: Facility, log_level: log::Leve
 
 /// UDP Logger init function compatible with log crate
 pub fn init_udp<T: ToSocketAddrs>(local: T, server: T, hostname:String, facility: Facility, log_level: log::LevelFilter) -> Result<()> {
-  let (process_name, pid) = get_process_info()?;
+  let (process, pid) = get_process_info()?;
   let formatter = Formatter3164 {
-    facility: facility.clone(),
+    facility,
     hostname: Some(hostname),
-    process:  process_name,
-    pid:      pid,
+    process,
+    pid,
   };
   udp(formatter, local, server).and_then(|logger| {
     log::set_boxed_logger(Box::new(BasicLogger::new(logger))).chain_err(|| ErrorKind::Initialization)
@@ -330,12 +330,12 @@ pub fn init_udp<T: ToSocketAddrs>(local: T, server: T, hostname:String, facility
 
 /// TCP Logger init function compatible with log crate
 pub fn init_tcp<T: ToSocketAddrs>(server: T, hostname: String, facility: Facility, log_level: log::LevelFilter) -> Result<()> {
-  let (process_name, pid) = get_process_info()?;
+  let (process, pid) = get_process_info()?;
   let formatter = Formatter3164 {
-    facility: facility.clone(),
+    facility,
     hostname: Some(hostname),
-    process:  process_name,
-    pid:      pid,
+    process,
+    pid,
   };
 
   tcp(formatter, server).and_then(|logger| {
@@ -363,13 +363,12 @@ pub fn init(facility: Facility, log_level: log::LevelFilter,
     -> Result<()>
 {
   let (process_name, pid) = get_process_info()?;
+  let process = application_name.map(From::from).unwrap_or(process_name);
   let formatter = Formatter3164 {
-    facility: facility.clone(),
+    facility,
     hostname: None,
-    process:  application_name
-      .map(|v| v.to_string())
-      .unwrap_or(process_name),
-    pid:      pid,
+    process,
+    pid,
   };
 
   let backend = unix(formatter.clone()).map(|logger: Logger<LoggerBackend, String, Formatter3164>| logger.backend)
@@ -383,8 +382,8 @@ pub fn init(facility: Facility, log_level: log::LevelFilter,
         .map(|s| LoggerBackend::Udp(s, udp_addr))
     })?;
   log::set_boxed_logger(    Box::new(BasicLogger::new(Logger {
-      formatter: formatter,
-      backend:   backend,
+      formatter,
+      backend,
       phantom:   PhantomData,
     }))
   ).chain_err(|| ErrorKind::Initialization)?;