*: Update formatting for Rust 1.31

Author: leoyvens

core/src/log/elastic.rs

@@ -191,7 +191,8 @@ impl ElasticDrain {
                                         "_type": config.document_type,
                                         "_id": log.id,
                                     }
-                                }).to_string();
+                                })
+                                .to_string();
 
                                 // Combine the two lines with newlines, make sure there is
                                 // a newline at the end as well
@@ -221,19 +222,22 @@ impl ElasticDrain {
                         .basic_auth(
                             config.general.username.clone().unwrap_or("".into()),
                             config.general.password.clone(),
-                        ).body(batch_body)
+                        )
+                        .body(batch_body)
                         .send()
                         .and_then(|response| response.error_for_status())
                         .map_err(|e| {
                             // Log if there was a problem sending the logs
                             error!(flush_logger, "Failed to send logs to Elasticsearch: {}", e);
-                        }).ok();
+                        })
+                        .ok();
 
                     // Clear the logs, so the next batch can be recorded
                     logs.clear();
 
                     Ok(())
-                }).map_err(move |e| {
+                })
+                .map_err(move |e| {
                     error!(
                         interval_error_logger,
                         "Error in Elasticsearch logger flush interval: {}", e

core/src/subgraph/instance_manager.rs

@@ -92,7 +92,8 @@ impl SubgraphInstanceManager {
                                     term_logger.clone(),
                                 ),
                             )
-                        }).unwrap_or(term_logger);
+                        })
+                        .unwrap_or(term_logger);
 
                     info!(logger, "Start subgraph");
 
@@ -103,7 +104,8 @@ impl SubgraphInstanceManager {
                         block_stream_builder.clone(),
                         store.clone(),
                         manifest,
-                    ).map_err(|err| error!(logger, "Failed to start subgraph: {}", err))
+                    )
+                    .map_err(|err| error!(logger, "Failed to start subgraph: {}", err))
                     .ok();
                 }
                 SubgraphStop(id) => {
@@ -171,7 +173,8 @@ impl SubgraphInstanceManager {
                         .iter()
                         .flat_map(|receipt| {
                             receipt.logs.iter().filter(|log| instance.matches_log(&log))
-                        }).cloned()
+                        })
+                        .cloned()
                         .collect();
 
                     if logs.len() == 0 {
@@ -211,9 +214,11 @@ impl SubgraphInstanceManager {
                                         transaction,
                                         log,
                                         entity_operations,
-                                    ).map_err(|e| format_err!("Failed to process event: {}", e))
+                                    )
+                                    .map_err(|e| format_err!("Failed to process event: {}", e))
                             })
-                        }).and_then(move |entity_operations| {
+                        })
+                        .and_then(move |entity_operations| {
                             let block = block_for_transact.clone();
                             let logger = logger_for_transact.clone();
 
@@ -233,14 +238,17 @@ impl SubgraphInstanceManager {
                                 block_ptr_now,
                                 block_ptr_after,
                                 entity_operations,
-                            )).map_err(|e| {
+                            ))
+                            .map_err(|e| {
                                 format_err!(
                                     "Error while processing block stream for a subgraph: {}",
                                     e
                                 )
-                            }).from_err()
+                            })
+                            .from_err()
                         })
-                }).map_err(move |e| match e {
+                })
+                .map_err(move |e| match e {
                     CancelableError::Cancel => {
                         info!(
                             error_logger,

core/src/subgraph/provider.rs

@@ -146,13 +146,15 @@ where
                             .duration_since(UNIX_EPOCH)
                             .unwrap()
                             .as_secs(),
-                    ).write_to_store(&*self_clone.store)
+                    )
+                    .write_to_store(&*self_clone.store)
                     .map_err(|err| {
                         error!(
                             self_clone.logger,
                             "Failed to write subgraph to store: {}", err
                         )
-                    }).ok();
+                    })
+                    .ok();
 
                     // Send events to trigger subgraph processing
                     Box::new(self_clone.send_add_events(subgraph).from_err())

core/src/subgraph/provider_with_names.rs

@@ -72,10 +72,12 @@ where
                     .map_err(CancelableError::Error)
                     .cancelable(&deployment_event_stream_cancel_handle, || {
                         CancelableError::Cancel
-                    }).for_each(move |deployment_event| {
+                    })
+                    .for_each(move |deployment_event| {
                         assert_eq!(deployment_event.node_id(), &node_id);
                         handle_deployment_event(deployment_event, provider.clone(), &logger_clone1)
-                    }).map_err(move |e| match e {
+                    })
+                    .map_err(move |e| match e {
                         CancelableError::Cancel => {}
                         CancelableError::Error(e) => {
                             error!(logger_clone2, "deployment event stream failed: {}", e);
@@ -206,7 +208,8 @@ where
                     Ok(()) => Ok(()),
                     Err(SubgraphProviderError::NotRunning(_)) => Ok(()),
                     Err(e) => Err(e),
-                }).map_err(CancelableError::Error),
+                })
+                .map_err(CancelableError::Error),
         ),
     }
 }