clippy and formatting

16 files changed, 106 insertions, 105 deletions

diff --git a/ipfs-cli/src/command/add.rs b/ipfs-cli/src/command/add.rs
index 0ff592d..40eeb3c 100644
--- a/ipfs-cli/src/command/add.rs
+++ b/ipfs-cli/src/command/add.rs
@@ -27,9 +27,9 @@ pub fn handle(core: &mut Core, client: &IpfsClient, args: &ArgMatches) {
     let file = File::open(path).expect(EXPECTED_FILE);
     let response = core.run(client.add(file)).expect(EXPECTED_API);
 
-    println!("");
+    println!();
     println!("  name    : {}", response.name);
     println!("  hash    : {}", response.hash);
     println!("  size    : {}", response.size);
-    println!("");
+    println!();
 }
diff --git a/ipfs-cli/src/command/bitswap.rs b/ipfs-cli/src/command/bitswap.rs
index 798670b..ed76107 100644
--- a/ipfs-cli/src/command/bitswap.rs
+++ b/ipfs-cli/src/command/bitswap.rs
@@ -38,20 +38,20 @@ pub fn handle(core: &mut Core, client: &IpfsClient, args: &ArgMatches) {
     match args.subcommand() {
         ("ledger", Some(args)) => {
             let peer = args.value_of("PEER").unwrap();
-            let ledger = core.run(client.bitswap_ledger(&peer)).expect(EXPECTED_API);
+            let ledger = core.run(client.bitswap_ledger(peer)).expect(EXPECTED_API);
 
-            println!("");
+            println!();
             println!("  peer      : {}", ledger.peer);
             println!("  value     : {}", ledger.value);
             println!("  sent      : {}", ledger.sent);
             println!("  recv      : {}", ledger.recv);
             println!("  exchanged : {}", ledger.exchanged);
-            println!("");
+            println!();
         }
         ("stat", _) => {
             let stat = core.run(client.bitswap_stat()).expect(EXPECTED_API);
 
-            println!("");
+            println!();
             println!("  provide_buf_len        : {}", stat.provide_buf_len);
             println!("  wantlist               :");
             for want in stat.wantlist {
@@ -67,27 +67,27 @@ pub fn handle(core: &mut Core, client: &IpfsClient, args: &ArgMatches) {
             println!("  data_sent              : {}", stat.data_sent);
             println!("  dup_blks_received      : {}", stat.dup_blks_received);
             println!("  dup_data_received      : {}", stat.dup_data_received);
-            println!("");
+            println!();
         }
         ("unwant", Some(args)) => {
             let key = args.value_of("KEY").unwrap();
 
-            core.run(client.bitswap_unwant(&key)).expect(EXPECTED_API);
+            core.run(client.bitswap_unwant(key)).expect(EXPECTED_API);
 
-            println!("");
+            println!();
             println!("  OK");
-            println!("");
+            println!();
         }
         ("wantlist", Some(args)) => {
             let peer = args.value_of("PEER");
             let wantlist = core.run(client.bitswap_wantlist(peer)).expect(EXPECTED_API);
 
-            println!("");
+            println!();
             println!("  wantlist               :");
             for key in wantlist.keys {
                 println!("    {}", key);
             }
-            println!("");
+            println!();
         }
         _ => unreachable!(),
     }
diff --git a/ipfs-cli/src/command/block.rs b/ipfs-cli/src/command/block.rs
index 24fa4eb..09bc660 100644
--- a/ipfs-cli/src/command/block.rs
+++ b/ipfs-cli/src/command/block.rs
@@ -54,30 +54,30 @@ pub fn handle(core: &mut Core, client: &IpfsClient, args: &ArgMatches) {
             let file = File::open(path).expect(EXPECTED_FILE);
             let block = core.run(client.block_put(file)).expect(EXPECTED_API);
 
-            println!("");
+            println!();
             println!("  key     : {}", block.key);
             println!("  size    : {}", block.size);
-            println!("");
+            println!();
         }
         ("rm", Some(args)) => {
             let key = args.value_of("KEY").unwrap();
             let rm = core.run(client.block_rm(key)).expect(EXPECTED_API);
 
-            println!("");
+            println!();
             println!("  hash    : {}", rm.hash);
             if let Some(error) = rm.error {
                 println!("  error   : {}", error);
             }
-            println!("");
+            println!();
         }
         ("stat", Some(args)) => {
             let key = args.value_of("KEY").unwrap();
             let stat = core.run(client.block_stat(key)).expect(EXPECTED_API);
 
-            println!("");
+            println!();
             println!("  key     : {}", stat.key);
             println!("  size    : {}", stat.size);
-            println!("");
+            println!();
         }
         _ => unreachable!(),
     }
diff --git a/ipfs-cli/src/command/bootstrap.rs b/ipfs-cli/src/command/bootstrap.rs
index 63c5925..fea60de 100644
--- a/ipfs-cli/src/command/bootstrap.rs
+++ b/ipfs-cli/src/command/bootstrap.rs
@@ -35,13 +35,13 @@ pub fn signature<'a, 'b>() -> App<'a, 'b> {
 }
 
 
-fn print_peers(peers: &Vec<String>) {
-    println!("");
+fn print_peers(peers: &[String]) {
+    println!();
     println!("  peers                  :");
     for peer in peers {
         println!("    {}", peer);
     }
-    println!("");
+    println!();
 }
 
 
diff --git a/ipfs-cli/src/command/cat.rs b/ipfs-cli/src/command/cat.rs
index 6216bc7..5bab711 100644
--- a/ipfs-cli/src/command/cat.rs
+++ b/ipfs-cli/src/command/cat.rs
@@ -25,7 +25,7 @@ pub fn signature<'a, 'b>() -> App<'a, 'b> {
 
 pub fn handle(core: &mut Core, client: &IpfsClient, args: &ArgMatches) {
     let path = args.value_of("PATH").unwrap();
-    let req = client.cat(&path).for_each(|chunk| {
+    let req = client.cat(path).for_each(|chunk| {
         io::stdout().write_all(&chunk).map_err(From::from)
     });
 
diff --git a/ipfs-cli/src/command/commands.rs b/ipfs-cli/src/command/commands.rs
index 481b5a0..05f787c 100644
--- a/ipfs-cli/src/command/commands.rs
+++ b/ipfs-cli/src/command/commands.rs
@@ -41,7 +41,7 @@ fn recursive_print_commands(cmd: CommandsResponse, stack: &mut Vec<String>) {
 pub fn handle(core: &mut Core, client: &IpfsClient) {
     let commands = core.run(client.commands()).expect(EXPECTED_API);
 
-    println!("");
+    println!();
     recursive_print_commands(commands, &mut Vec::new());
-    println!("");
+    println!();
 }
diff --git a/ipfs-cli/src/command/dag.rs b/ipfs-cli/src/command/dag.rs
index e27375f..81250a5 100644
--- a/ipfs-cli/src/command/dag.rs
+++ b/ipfs-cli/src/command/dag.rs
@@ -30,7 +30,7 @@ pub fn handle(core: &mut Core, client: &IpfsClient, args: &ArgMatches) {
             let key = args.value_of("KEY").unwrap();
             let dag = core.run(client.dag_get(key)).expect(EXPECTED_API);
 
-            println!("");
+            println!();
             if let Some(data) = dag.data {
                 println!("  data                   :");
                 println!("{}", data);
@@ -39,7 +39,7 @@ pub fn handle(core: &mut Core, client: &IpfsClient, args: &ArgMatches) {
             for link in dag.links {
                 println!("    {} ({}) ({:?})", link.name, link.size, link.cid);
             }
-            println!("");
+            println!();
         }
         _ => unreachable!(),
     }
diff --git a/ipfs-cli/src/command/dht.rs b/ipfs-cli/src/command/dht.rs
index 44d4aa0..ede7858 100644
--- a/ipfs-cli/src/command/dht.rs
+++ b/ipfs-cli/src/command/dht.rs
@@ -48,7 +48,7 @@ pub fn signature<'a, 'b>() -> App<'a, 'b> {
 
 
 fn print_dht_response<E>(res: DhtMessage) -> Result<(), E> {
-    println!("");
+    println!();
     println!("  id                     : {}", res.id);
     println!("  type                   : {:?}", res.typ);
     println!("  responses              :");
@@ -58,10 +58,10 @@ fn print_dht_response<E>(res: DhtMessage) -> Result<(), E> {
         for addr in peer_res.addrs {
             println!("      {}", addr);
         }
-        println!("");
+        println!();
     }
     println!("  extra                  : {}", res.extra);
-    println!("");
+    println!();
 
     Ok(())
 }
@@ -72,34 +72,33 @@ pub fn handle(core: &mut Core, client: &IpfsClient, args: &ArgMatches) {
         ("findpeer", Some(args)) => {
             let peer = args.value_of("PEER").unwrap();
 
-            client.dht_findpeer(&peer)
+            client.dht_findpeer(peer)
         }
         ("findprovs", Some(args)) => {
             let key = args.value_of("KEY").unwrap();
 
-            client.dht_findprovs(&key)
+            client.dht_findprovs(key)
         }
         ("get", Some(args)) => {
             let key = args.value_of("KEY").unwrap();
 
-            client.dht_get(&key)
+            client.dht_get(key)
         }
         ("provide", Some(args)) => {
             let key = args.value_of("KEY").unwrap();
 
-            client.dht_provide(&key)
-
+            client.dht_provide(key)
         }
         ("put", Some(args)) => {
             let key = args.value_of("KEY").unwrap();
             let val = args.value_of("VALUE").unwrap();
 
-            client.dht_put(&key, &val)
+            client.dht_put(key, val)
         }
         ("query", Some(args)) => {
             let peer = args.value_of("PEER").unwrap();
 
-            client.dht_query(&peer)
+            client.dht_query(peer)
         }
         _ => unreachable!(),
     };
diff --git a/ipfs-cli/src/command/diag.rs b/ipfs-cli/src/command/diag.rs
index 24f65aa..644de19 100644
--- a/ipfs-cli/src/command/diag.rs
+++ b/ipfs-cli/src/command/diag.rs
@@ -46,20 +46,20 @@ pub fn handle(core: &mut Core, client: &IpfsClient, args: &ArgMatches) {
                 ("clear", _) => {
                     core.run(client.diag_cmds_clear()).expect(EXPECTED_API);
 
-                    println!("");
+                    println!();
                     println!("  OK");
-                    println!("");
+                    println!();
                 }
                 ("set-time", Some(args)) => {
                     let time = args.value_of("TIME").unwrap();
 
-                    core.run(client.diag_cmds_set_time(&time)).expect(
+                    core.run(client.diag_cmds_set_time(time)).expect(
                         EXPECTED_API,
                     );
 
-                    println!("");
+                    println!();
                     println!("  OK");
-                    println!("");
+                    println!();
                 }
                 _ => unreachable!(),
             }
@@ -67,9 +67,9 @@ pub fn handle(core: &mut Core, client: &IpfsClient, args: &ArgMatches) {
         ("sys", _) => {
             let sys = core.run(client.diag_sys()).expect(EXPECTED_API);
 
-            println!("");
+            println!();
             println!("  {}", sys);
-            println!("");
+            println!();
         }
         _ => unreachable!(),
     }
diff --git a/ipfs-cli/src/command/dns.rs b/ipfs-cli/src/command/dns.rs
index e9ab0fa..c40f61b 100644
--- a/ipfs-cli/src/command/dns.rs
+++ b/ipfs-cli/src/command/dns.rs
@@ -24,10 +24,10 @@ pub fn signature<'a, 'b>() -> App<'a, 'b> {
 
 pub fn handle(core: &mut Core, client: &IpfsClient, args: &ArgMatches) {
     let path = args.value_of("PATH").unwrap();
-    let req = client.dns(&path, args.is_present("recursive"));
+    let req = client.dns(path, args.is_present("recursive"));
     let res = core.run(req).expect(EXPECTED_API);
 
-    println!("");
+    println!();
     println!("  path    : {}", res.path);
-    println!("");
+    println!();
 }
diff --git a/ipfs-cli/src/command/file.rs b/ipfs-cli/src/command/file.rs
index 9a007a3..1d7da87 100644
--- a/ipfs-cli/src/command/file.rs
+++ b/ipfs-cli/src/command/file.rs
@@ -28,14 +28,14 @@ pub fn handle(core: &mut Core, client: &IpfsClient, args: &ArgMatches) {
     match args.subcommand() {
         ("ls", Some(args)) => {
             let path = args.value_of("PATH").unwrap();
-            let ls = core.run(client.file_ls(&path)).expect(EXPECTED_API);
+            let ls = core.run(client.file_ls(path)).expect(EXPECTED_API);
 
-            println!("");
+            println!();
             println!("  arguments              :");
             for (k, arg) in ls.arguments {
                 println!("    arg        : {}", k);
                 println!("    value      : {}", arg);
-                println!("");
+                println!();
             }
             println!("  objects                :");
             for (k, obj) in ls.objects {
@@ -51,10 +51,10 @@ pub fn handle(core: &mut Core, client: &IpfsClient, args: &ArgMatches) {
                     if let Some(ref typ) = link.typ {
                         println!("      type       : {}", typ);
                     }
-                    println!("");
+                    println!();
                 }
             }
-            println!("");
+            println!();
         }
         _ => unreachable!(),
     }
diff --git a/ipfs-cli/src/command/files.rs b/ipfs-cli/src/command/files.rs
index 00329a9..1f1564e 100644
--- a/ipfs-cli/src/command/files.rs
+++ b/ipfs-cli/src/command/files.rs
@@ -73,59 +73,59 @@ pub fn handle(core: &mut Core, client: &IpfsClient, args: &ArgMatches) {
             let src = args.value_of("SRC").unwrap();
             let dest = args.value_of("DEST").unwrap();
 
-            core.run(client.files_cp(&src, &dest)).expect(EXPECTED_API);
+            core.run(client.files_cp(src, dest)).expect(EXPECTED_API);
 
-            println!("");
+            println!();
             println!("  OK");
-            println!("");
+            println!();
         }
         ("flush", Some(args)) => {
             let path = args.value_of("PATH");
 
             core.run(client.files_flush(&path)).expect(EXPECTED_API);
 
-            println!("");
+            println!();
             println!("  OK");
-            println!("");
+            println!();
         }
         ("ls", Some(args)) => {
             let path = args.value_of("PATH");
             let ls = core.run(client.files_ls(&path)).expect(EXPECTED_API);
 
-            println!("");
+            println!();
             println!("  entries                :");
             for entry in ls.entries {
                 println!("    name       : {}", entry.name);
                 println!("    type       : {}", entry.typ);
                 println!("    size       : {}", entry.size);
                 println!("    hash       : {}", entry.hash);
-                println!("");
+                println!();
             }
-            println!("");
+            println!();
         }
         ("mkdir", Some(args)) => {
             let path = args.value_of("PATH").unwrap();
 
-            core.run(client.files_mkdir(&path, args.is_present("parents")))
+            core.run(client.files_mkdir(path, args.is_present("parents")))
                 .expect(EXPECTED_API);
 
-            println!("");
+            println!();
             println!("  OK");
-            println!("");
+            println!();
         }
         ("mv", Some(args)) => {
             let src = args.value_of("SRC").unwrap();
             let dest = args.value_of("DEST").unwrap();
 
-            core.run(client.files_mv(&src, &dest)).expect(EXPECTED_API);
+            core.run(client.files_mv(src, dest)).expect(EXPECTED_API);
 
-            println!("");
+            println!();
             println!("  OK");
-            println!("");
+            println!();
         }
         ("read", Some(args)) => {
             let path = args.value_of("PATH").unwrap();
-            let req = client.files_read(&path).for_each(|chunk| {
+            let req = client.files_read(path).for_each(|chunk| {
                 io::stdout().write_all(&chunk).map_err(From::from)
             });
 
@@ -133,32 +133,32 @@ pub fn handle(core: &mut Core, client: &IpfsClient, args: &ArgMatches) {
         }
         ("rm", Some(args)) => {
             let path = args.value_of("PATH").unwrap();
-            let req = client.files_rm(&path, args.is_present("recursive"));
+            let req = client.files_rm(path, args.is_present("recursive"));
 
             core.run(req).expect(EXPECTED_API);
 
-            println!("");
+            println!();
             println!("  OK");
-            println!("");
+            println!();
         }
         ("stat", Some(args)) => {
             let path = args.value_of("PATH").unwrap();
-            let stat = core.run(client.files_stat(&path)).expect(EXPECTED_API);
+            let stat = core.run(client.files_stat(path)).expect(EXPECTED_API);
 
-            println!("");
+            println!();
             println!("  hash                   : {}", stat.hash);
             println!("  size                   : {}", stat.size);
             println!("  cumulative_size        : {}", stat.cumulative_size);
             println!("  blocks                 : {}", stat.blocks);
             println!("  type                   : {}", stat.typ);
-            println!("");
+            println!();
         }
         ("write", Some(args)) => {
             let dest = args.value_of("DEST").unwrap();
             let path = args.value_of("INPUT").unwrap();
             let file = File::open(path).expect(EXPECTED_FILE);
             let req = client.files_write(
-                &dest,
+                dest,
                 args.is_present("create"),
                 args.is_present("truncate"),
                 file,
@@ -166,9 +166,9 @@ pub fn handle(core: &mut Core, client: &IpfsClient, args: &ArgMatches) {
 
             core.run(req).expect(EXPECTED_API);
 
-            println!("");
+            println!();
             println!("  OK");
-            println!("");
+            println!();
         }
         _ => unreachable!(),
     }
diff --git a/ipfs-cli/src/command/filestore.rs b/ipfs-cli/src/command/filestore.rs
index b24da2c..a14b055 100644
--- a/ipfs-cli/src/command/filestore.rs
+++ b/ipfs-cli/src/command/filestore.rs
@@ -32,14 +32,14 @@ pub fn signature<'a, 'b>() -> App<'a, 'b> {
 }
 
 
-fn print_filestore_object<E>(obj: response::FilestoreObject) -> Result<(), E> {
+fn print_filestore_object<E>(obj: &response::FilestoreObject) -> Result<(), E> {
     println!("  status                 : {}", obj.status);
     println!("  error_msg              : {}", obj.error_msg);
     println!("  key                    : {}", obj.key);
     println!("  file_path              : {}", obj.file_path);
     println!("  offset                 : {}", obj.offset);
     println!("  size                   : {}", obj.size);
-    println!("");
+    println!();
 
     Ok(())
 }
@@ -51,32 +51,34 @@ pub fn handle(core: &mut Core, client: &IpfsClient, args: &ArgMatches) {
             let req = client.filestore_dups().for_each(|dup| {
                 println!("  ref     : {}", dup.reference);
                 println!("  err     : {}", dup.err);
-                println!("");
+                println!();
 
                 Ok(())
             });
 
-            println!("");
+            println!();
             core.run(req).expect(EXPECTED_API);
-            println!("");
+            println!();
         }
         ("ls", Some(args)) => {
             let cid = args.value_of("CID");
-            let req = client.filestore_ls(&cid).for_each(print_filestore_object);
+            let req = client.filestore_ls(&cid).for_each(
+                |res| print_filestore_object(&res),
+            );
 
-            println!("");
+            println!();
             core.run(req).expect(EXPECTED_API);
-            println!("");
+            println!();
         }
         ("verify", Some(args)) => {
             let cid = args.value_of("CID");
-            let req = client.filestore_verify(&cid).for_each(
-                print_filestore_object,
-            );
+            let req = client.filestore_verify(&cid).for_each(|res| {
+                print_filestore_object(&res)
+            });
 
-            println!("");
+            println!();
             core.run(req).expect(EXPECTED_API);
-            println!("");
+            println!();
         }
         _ => unreachable!(),
     }
diff --git a/ipfs-cli/src/command/mod.rs b/ipfs-cli/src/command/mod.rs
index b260902..7d12053 100644
--- a/ipfs-cli/src/command/mod.rs
+++ b/ipfs-cli/src/command/mod.rs
@@ -10,8 +10,8 @@ use std::error::Error;
 use std::fs;
 
 
-pub const EXPECTED_API: &'static str = "expected response from API";
-pub const EXPECTED_FILE: &'static str = "expected to read input file";
+pub const EXPECTED_API: &str = "expected response from API";
+pub const EXPECTED_FILE: &str = "expected to read input file";
 
 
 /// Verifies that a path points to a file that exists, and not a directory.
diff --git a/ipfs-cli/src/command/version.rs b/ipfs-cli/src/command/version.rs
index 380cd8b..d8fbafa 100644
--- a/ipfs-cli/src/command/version.rs
+++ b/ipfs-cli/src/command/version.rs
@@ -24,11 +24,11 @@ pub fn handle(core: &mut Core, client: &IpfsClient) {
         "expected response from API",
     );
 
-    println!("");
+    println!();
     println!("  version : {}", version.version);
     println!("  commit  : {}", version.commit);
     println!("  repo    : {}", version.repo);
     println!("  system  : {}", version.system);
     println!("  golang  : {}", version.golang);
-    println!("");
+    println!();
 }
diff --git a/ipfs-cli/src/main.rs b/ipfs-cli/src/main.rs
index e373910..b0262aa 100644
--- a/ipfs-cli/src/main.rs
+++ b/ipfs-cli/src/main.rs
@@ -46,20 +46,20 @@ fn main() {
     let client = IpfsClient::default(&core.handle());
 
     match matches.subcommand() {
-        ("add", Some(args)) => command::add::handle(&mut core, &client, &args),
-        ("bitswap", Some(args)) => command::bitswap::handle(&mut core, &client, &args),
-        ("block", Some(args)) => command::block::handle(&mut core, &client, &args),
-        ("bootstrap", Some(args)) => command::bootstrap::handle(&mut core, &client, &args),
-        ("cat", Some(args)) => command::cat::handle(&mut core, &client, &args),
+        ("add", Some(args)) => command::add::handle(&mut core, &client, args),
+        ("bitswap", Some(args)) => command::bitswap::handle(&mut core, &client, args),
+        ("block", Some(args)) => command::block::handle(&mut core, &client, args),
+        ("bootstrap", Some(args)) => command::bootstrap::handle(&mut core, &client, args),
+        ("cat", Some(args)) => command::cat::handle(&mut core, &client, args),
         ("commands", _) => command::commands::handle(&mut core, &client),
-        ("config", Some(args)) => command::config::handle(&mut core, &client, &args),
-        ("dag", Some(args)) => command::dag::handle(&mut core, &client, &args),
-        ("dht", Some(args)) => command::dht::handle(&mut core, &client, &args),
-        ("diag", Some(args)) => command::diag::handle(&mut core, &client, &args),
-        ("dns", Some(args)) => command::dns::handle(&mut core, &client, &args),
-        ("file", Some(args)) => command::file::handle(&mut core, &client, &args),
-        ("files", Some(args)) => command::files::handle(&mut core, &client, &args),
-        ("filestore", Some(args)) => command::filestore::handle(&mut core, &client, &args),
+        ("config", Some(args)) => command::config::handle(&mut core, &client, args),
+        ("dag", Some(args)) => command::dag::handle(&mut core, &client, args),
+        ("dht", Some(args)) => command::dht::handle(&mut core, &client, args),
+        ("diag", Some(args)) => command::diag::handle(&mut core, &client, args),
+        ("dns", Some(args)) => command::dns::handle(&mut core, &client, args),
+        ("file", Some(args)) => command::file::handle(&mut core, &client, args),
+        ("files", Some(args)) => command::files::handle(&mut core, &client, args),
+        ("filestore", Some(args)) => command::filestore::handle(&mut core, &client, args),
         ("version", _) => command::version::handle(&mut core, &client),
         _ => unreachable!(),
     }