style: Update to 2018 edition

Cargo.toml

@@ -10,6 +10,7 @@ documentation = "http://docs.rs/assert_cmd/"
 readme = "README.md"
 categories = ["development-tools::testing"]
 keywords = ["cli", "test", "assert", "command", "duct"]
+edition = "2018"
 
 [[bin]]
 name = "bin_fixture"

examples/example_fixture.rs

@@ -4,7 +4,7 @@ use std::io;
 use std::io::Write;
 use std::process;
 
-fn run() -> Result<(), Box<Error>> {
+fn run() -> Result<(), Box<dyn Error>> {
     if let Ok(text) = env::var("stdout") {
         println!("{}", text);
     }

src/assert.rs

@@ -11,8 +11,8 @@ use predicates::str::PredicateStrExt;
 use predicates_core;
 use predicates_tree::CaseTreeExt;
 
-use cmd::dump_buffer;
-use cmd::output_fmt;
+use crate::cmd::dump_buffer;
+use crate::cmd::output_fmt;
 
 /// Assert the state of an [`Output`].
 ///
@@ -84,7 +84,7 @@ impl<'c> OutputAssertExt for &'c mut process::Command {
 /// [`OutputAssertExt`]: trait.OutputAssertExt.html
 pub struct Assert {
     output: process::Output,
-    context: Vec<(&'static str, Box<fmt::Display>)>,
+    context: Vec<(&'static str, Box<dyn fmt::Display>)>,
 }
 
 impl Assert {
@@ -252,7 +252,7 @@ impl Assert {
         self.code_impl(&pred.into_code())
     }
 
-    fn code_impl(self, pred: &predicates_core::Predicate<i32>) -> Self {
+    fn code_impl(self, pred: &dyn predicates_core::Predicate<i32>) -> Self {
         let actual_code = self
             .output
             .status
@@ -346,7 +346,7 @@ impl Assert {
         self.stdout_impl(&pred.into_output())
     }
 
-    fn stdout_impl(self, pred: &predicates_core::Predicate<[u8]>) -> Self {
+    fn stdout_impl(self, pred: &dyn predicates_core::Predicate<[u8]>) -> Self {
         {
             let actual = &self.output.stdout;
             if let Some(case) = pred.find_case(false, &actual) {
@@ -438,7 +438,7 @@ impl Assert {
         self.stderr_impl(&pred.into_output())
     }
 
-    fn stderr_impl(self, pred: &predicates_core::Predicate<[u8]>) -> Self {
+    fn stderr_impl(self, pred: &dyn predicates_core::Predicate<[u8]>) -> Self {
         {
             let actual = &self.output.stderr;
             if let Some(case) = pred.find_case(false, &actual) {
@@ -450,7 +450,7 @@ impl Assert {
 }
 
 impl fmt::Display for Assert {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         for &(ref name, ref context) in &self.context {
             writeln!(f, "{}=`{}`", name, context)?;
         }
@@ -459,7 +459,7 @@ impl fmt::Display for Assert {
 }
 
 impl fmt::Debug for Assert {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_struct("Assert")
             .field("output", &self.output)
             .finish()
@@ -550,12 +550,12 @@ impl EqCodePredicate {
 impl predicates_core::reflection::PredicateReflection for EqCodePredicate {
     fn parameters<'a>(
         &'a self,
-    ) -> Box<Iterator<Item = predicates_core::reflection::Parameter<'a>> + 'a> {
+    ) -> Box<dyn Iterator<Item = predicates_core::reflection::Parameter<'a>> + 'a> {
         self.0.parameters()
     }
 
     /// Nested `Predicate`s of the current `Predicate`.
-    fn children<'a>(&'a self) -> Box<Iterator<Item = predicates_core::reflection::Child<'a>> + 'a> {
+    fn children<'a>(&'a self) -> Box<dyn Iterator<Item = predicates_core::reflection::Child<'a>> + 'a> {
         self.0.children()
     }
 }
@@ -575,7 +575,7 @@ impl predicates_core::Predicate<i32> for EqCodePredicate {
 }
 
 impl fmt::Display for EqCodePredicate {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         self.0.fmt(f)
     }
 }
@@ -620,12 +620,12 @@ impl InCodePredicate {
 impl predicates_core::reflection::PredicateReflection for InCodePredicate {
     fn parameters<'a>(
         &'a self,
-    ) -> Box<Iterator<Item = predicates_core::reflection::Parameter<'a>> + 'a> {
+    ) -> Box<dyn Iterator<Item = predicates_core::reflection::Parameter<'a>> + 'a> {
         self.0.parameters()
     }
 
     /// Nested `Predicate`s of the current `Predicate`.
-    fn children<'a>(&'a self) -> Box<Iterator<Item = predicates_core::reflection::Child<'a>> + 'a> {
+    fn children<'a>(&'a self) -> Box<dyn Iterator<Item = predicates_core::reflection::Child<'a>> + 'a> {
         self.0.children()
     }
 }
@@ -645,7 +645,7 @@ impl predicates_core::Predicate<i32> for InCodePredicate {
 }
 
 impl fmt::Display for InCodePredicate {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         self.0.fmt(f)
     }
 }
@@ -754,12 +754,12 @@ impl BytesContentOutputPredicate {
 impl predicates_core::reflection::PredicateReflection for BytesContentOutputPredicate {
     fn parameters<'a>(
         &'a self,
-    ) -> Box<Iterator<Item = predicates_core::reflection::Parameter<'a>> + 'a> {
+    ) -> Box<dyn Iterator<Item = predicates_core::reflection::Parameter<'a>> + 'a> {
         self.0.parameters()
     }
 
     /// Nested `Predicate`s of the current `Predicate`.
-    fn children<'a>(&'a self) -> Box<Iterator<Item = predicates_core::reflection::Child<'a>> + 'a> {
+    fn children<'a>(&'a self) -> Box<dyn Iterator<Item = predicates_core::reflection::Child<'a>> + 'a> {
         self.0.children()
     }
 }
@@ -779,7 +779,7 @@ impl predicates_core::Predicate<[u8]> for BytesContentOutputPredicate {
 }
 
 impl fmt::Display for BytesContentOutputPredicate {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         self.0.fmt(f)
     }
 }
@@ -833,12 +833,12 @@ impl StrContentOutputPredicate {
 impl predicates_core::reflection::PredicateReflection for StrContentOutputPredicate {
     fn parameters<'a>(
         &'a self,
-    ) -> Box<Iterator<Item = predicates_core::reflection::Parameter<'a>> + 'a> {
+    ) -> Box<dyn Iterator<Item = predicates_core::reflection::Parameter<'a>> + 'a> {
         self.0.parameters()
     }
 
     /// Nested `Predicate`s of the current `Predicate`.
-    fn children<'a>(&'a self) -> Box<Iterator<Item = predicates_core::reflection::Child<'a>> + 'a> {
+    fn children<'a>(&'a self) -> Box<dyn Iterator<Item = predicates_core::reflection::Child<'a>> + 'a> {
         self.0.children()
     }
 }
@@ -858,7 +858,7 @@ impl predicates_core::Predicate<[u8]> for StrContentOutputPredicate {
 }
 
 impl fmt::Display for StrContentOutputPredicate {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         self.0.fmt(f)
     }
 }
@@ -924,12 +924,12 @@ where
 {
     fn parameters<'a>(
         &'a self,
-    ) -> Box<Iterator<Item = predicates_core::reflection::Parameter<'a>> + 'a> {
+    ) -> Box<dyn Iterator<Item = predicates_core::reflection::Parameter<'a>> + 'a> {
         self.0.parameters()
     }
 
     /// Nested `Predicate`s of the current `Predicate`.
-    fn children<'a>(&'a self) -> Box<Iterator<Item = predicates_core::reflection::Child<'a>> + 'a> {
+    fn children<'a>(&'a self) -> Box<dyn Iterator<Item = predicates_core::reflection::Child<'a>> + 'a> {
         self.0.children()
     }
 }
@@ -955,7 +955,7 @@ impl<P> fmt::Display for StrOutputPredicate<P>
 where
     P: predicates_core::Predicate<str>,
 {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         self.0.fmt(f)
     }
 }

src/bin/bin_fixture.rs

@@ -4,7 +4,7 @@ use std::io;
 use std::io::Write;
 use std::process;
 
-fn run() -> Result<(), Box<Error>> {
+fn run() -> Result<(), Box<dyn Error>> {
     if let Ok(text) = env::var("stdout") {
         println!("{}", text);
     }

src/cargo.rs

@@ -138,7 +138,7 @@ impl CommandCargoExt for process::Command {
 /// Error when finding crate binary.
 #[derive(Debug)]
 pub struct CargoError {
-    cause: Option<Box<Error + Send + Sync + 'static>>,
+    cause: Option<Box<dyn Error + Send + Sync + 'static>>,
 }
 
 impl CargoError {
@@ -157,16 +157,16 @@ impl Error for CargoError {
         "Cargo command failed."
     }
 
-    fn cause(&self) -> Option<&Error> {
+    fn cause(&self) -> Option<&dyn Error> {
         self.cause.as_ref().map(|c| {
-            let c: &Error = c.as_ref();
+            let c: &dyn Error = c.as_ref();
             c
         })
     }
 }
 
 impl fmt::Display for CargoError {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         if let Some(ref cause) = self.cause {
             writeln!(f, "Cause: {}", cause)?;
         }
@@ -185,13 +185,13 @@ impl Error for NotFoundError {
         "Cargo command not found."
     }
 
-    fn cause(&self) -> Option<&Error> {
+    fn cause(&self) -> Option<&dyn Error> {
         None
     }
 }
 
 impl fmt::Display for NotFoundError {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         writeln!(f, "Cargo command not found: {}", self.path.display())
     }
 }

src/cmd.rs

@@ -247,7 +247,7 @@ impl Error for OutputError {
         "Command failed."
     }
 
-    fn cause(&self) -> Option<&Error> {
+    fn cause(&self) -> Option<&dyn Error> {
         if let OutputCause::Unexpected(ref err) = self.cause {
             Some(err.as_ref())
         } else {
@@ -257,7 +257,7 @@ impl Error for OutputError {
 }
 
 impl fmt::Display for OutputError {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         if let Some(ref cmd) = self.cmd {
             writeln!(f, "command=`{}`", cmd)?;
         }
@@ -275,11 +275,11 @@ impl fmt::Display for OutputError {
 #[derive(Debug)]
 enum OutputCause {
     Expected(Output),
-    Unexpected(Box<Error + Send + Sync + 'static>),
+    Unexpected(Box<dyn Error + Send + Sync + 'static>),
 }
 
 impl fmt::Display for OutputCause {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match *self {
             OutputCause::Expected(ref e) => write!(f, "{}", e),
             OutputCause::Unexpected(ref e) => write!(f, "{}", e),
@@ -293,12 +293,12 @@ struct Output {
 }
 
 impl fmt::Display for Output {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         output_fmt(&self.output, f)
     }
 }
 
-pub(crate) fn output_fmt(output: &process::Output, f: &mut fmt::Formatter) -> fmt::Result {
+pub(crate) fn output_fmt(output: &process::Output, f: &mut fmt::Formatter<'_>) -> fmt::Result {
     if let Some(code) = output.status.code() {
         writeln!(f, "code={}", code)?;
     } else {
@@ -324,7 +324,7 @@ pub(crate) fn dump_buffer(buffer: &[u8]) -> String {
     }
 }
 
-pub(crate) fn write_buffer(buffer: &[u8], f: &mut fmt::Formatter) -> fmt::Result {
+pub(crate) fn write_buffer(buffer: &[u8], f: &mut fmt::Formatter<'_>) -> fmt::Result {
     if let Ok(buffer) = str::from_utf8(buffer) {
         write!(f, "{}", buffer)
     } else {
@@ -344,7 +344,7 @@ impl DebugBuffer {
 }
 
 impl fmt::Display for DebugBuffer {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write_buffer(&self.buffer, f)
     }
 }

src/lib.rs

@@ -108,11 +108,6 @@
 
 #![warn(missing_docs)]
 
-extern crate escargot;
-extern crate predicates;
-extern crate predicates_core;
-extern crate predicates_tree;
-
 /// Allows you to pull the name from your Cargo.toml at compile time.
 ///
 /// # Examples
@@ -154,10 +149,10 @@ pub mod stdin;
 
 /// Extension traits that are useful to have available.
 pub mod prelude {
-    pub use assert::OutputAssertExt;
-    pub use cargo::CommandCargoExt;
-    pub use cmd::OutputOkExt;
-    pub use stdin::CommandStdInExt;
+    pub use crate::assert::OutputAssertExt;
+    pub use crate::cargo::CommandCargoExt;
+    pub use crate::cmd::OutputOkExt;
+    pub use crate::stdin::CommandStdInExt;
 }
 
 #[macro_use]