Bad Rustfmt formattings

rustfmt.toml

@@ -0,0 +1,5 @@
+fn_args_layout = "Block"
+array_layout = "Block"
+where_style = "Rfc"
+generics_indent = "Block"
+fn_call_style = "Block"

waltz/src/code_block.rs

@@ -62,7 +62,7 @@ impl CodeBlock {
  let path = Path::new(root.as_ref()).join(&self.filename());
  let parent = match path.parent() {
  Some(p) => p,
- None => bail!("Can't create file for code block, path has no parent directory"),
+ None => bail!("Can't create file for code block, path has no parent directory",),
  };
 
  create_dir_all(parent)?;
@@ -82,7 +82,8 @@ mod test {
 
  #[test]
  fn parsing() {
- let example = unindent(r#"
+ let example = unindent(
+ r#"
  # Lorem ipsum
 
  ## Shell
@@ -98,7 +99,8 @@ mod test {
  println!("Dolor sit amet");
  }
  ```
- "#);
+ "#,
+ );
 
  let markdown = ::pulldown_cmark::Parser::new(&example);
  let code_blocks = ::extract_code_blocks(markdown).unwrap();

waltz_cli/src/cli.rs

@@ -5,19 +5,22 @@ pub fn app() -> App<'static, 'static> {
  .version(crate_version!())
  .author("Pascal Hertleif <killercup@gmail.com>")
  .about("Extract code blocks from Markdown and save them as files.")
- .arg(Arg::with_name("input_file")
- .help("The input markdown file")
- .index(1)
- .required(true)
+ .arg(
+ Arg::with_name("input_file")
+ .help("The input markdown file")
+ .index(1)
+ .required(true),
  )
- .arg(Arg::with_name("target_dir")
- .help("The target directory")
- .short("o")
- .takes_value(true)
+ .arg(
+ Arg::with_name("target_dir")
+ .help("The target directory")
+ .short("o")
+ .takes_value(true),
  )
- .arg(Arg::with_name("v")
- .short("v")
- .help("Enable logging, use multiple `v`s to increase verbosity")
- .multiple(true)
+ .arg(
+ Arg::with_name("v")
+ .short("v")
+ .help("Enable logging, use multiple `v`s to increase verbosity")
+ .multiple(true),
  )
 }

waltz_cli/src/main.rs

@@ -37,8 +37,8 @@ fn try_main() -> Result<()> {
  // Parse markdown file
  let input = {
  let mut res = String::new();
- let mut f = File::open(input_file)
- .chain_err(|| format!("Error opening file `{}`", input_file))?;
+ let mut f =
+ File::open(input_file).chain_err(|| format!("Error opening file `{}`", input_file))?;
  f.read_to_string(&mut res)
  .chain_err(|| format!("Error reading file `{}`", input_file))?;
  info!("Read file `{}`", input_file);
@@ -48,7 +48,10 @@ fn try_main() -> Result<()> {
 
  let code_blocks = waltz::extract_code_blocks(parser)?;
 
- info!("Found {} code blocks (not all might have file names)", code_blocks.len());
+ info!(
+ "Found {} code blocks (not all might have file names)",
+ code_blocks.len(),
+ );
 
  // Output files
  for code_block in code_blocks.iter().filter(|cb| cb.has_filename()) {

waltz_cli/tests/concat.rs

@@ -3,7 +3,8 @@ use utils::*;
 
 #[test]
 fn concat() {
- given(r#"
+ given(
+ r#"
  # Getting started
 
  First of all, create a simple `Cargo.toml` file:
@@ -45,15 +46,22 @@ fn concat() {
  }
  }
  ```
- "#)
- .running(waltz)
- .creates(file("Cargo.toml").containing(r#"
+ "#,
+ )
+ .running(waltz)
+ .creates(
+ file("Cargo.toml").containing(
+ r#"
  [package]
  authors = ["Pascal Hertleif <killercup@gmail.com>"]
  name = "foo"
  version = "0.1.0"
- "#))
- .creates(file("src/lib.rs").containing(r#"
+ "#,
+ ),
+ )
+ .creates(
+ file("src/lib.rs").containing(
+ r#"
  struct Foo {
  x: i32,
  }
@@ -69,6 +77,8 @@ fn concat() {
  Foo { x: 42 }
  }
  }
- "#))
- .running(cargo_check);
+ "#,
+ ),
+ )
+ .running(cargo_check);
 }

waltz_cli/tests/simple.rs

@@ -3,7 +3,8 @@ use utils::*;
 
 #[test]
 fn simple() {
- given(r#"
+ given(
+ r#"
  # Getting started
 
  First of all, create a simple `Cargo.toml` file:
@@ -22,25 +23,35 @@ fn simple() {
  println!("Hello, world!");
  }
  ```
- "#)
- .running(waltz)
- .creates(file("Cargo.toml").containing(r#"
+ "#,
+ )
+ .running(waltz)
+ .creates(
+ file("Cargo.toml").containing(
+ r#"
  [package]
  authors = ["Pascal Hertleif <killercup@gmail.com>"]
  name = "foo"
  version = "0.1.0"
- "#))
- .creates(file("src/main.rs").containing(r#"
+ "#,
+ ),
+ )
+ .creates(
+ file("src/main.rs").containing(
+ r#"
  fn main() {
  println!("Hello, world!");
  }
- "#))
- .running(|cwd| main(cwd).prints("Hello, world!"));
+ "#,
+ ),
+ )
+ .running(|cwd| main(cwd).prints("Hello, world!"));
 }
 
 #[test]
 fn complex_paths() {
- given(r#"
+ given(
+ r#"
  First off:
 
  ```toml,file=Cargo.toml
@@ -61,11 +72,10 @@ fn complex_paths() {
  println!("Sup dawg I herd u likd nested dirs");
  }
  ```
- "#)
- .running(waltz)
- .creates(file("Cargo.toml"))
- .creates(file("src/bin/lolwut/main.rs"))
- .running(|cwd| binary(cwd, "lolwut")
- .prints("Sup dawg")
- );
+ "#,
+ )
+ .running(waltz)
+ .creates(file("Cargo.toml"))
+ .creates(file("src/bin/lolwut/main.rs"))
+ .running(|cwd| binary(cwd, "lolwut").prints("Sup dawg"));
 }

waltz_cli/tests/utils/mod.rs

@@ -25,34 +25,29 @@ pub fn file(path: &str) -> FileAssert {
 
 pub fn waltz(cwd: &Path) -> CliAssert {
  CliAssert::main_binary()
- .with_args(&[
- "-vvv",
- cwd.join("test.md").to_str().unwrap(),
- "-o", cwd.to_str().unwrap(),
- ])
+ .with_args(&["-vvv", cwd.join("test.md").to_str().unwrap(), "-o", cwd.to_str().unwrap()],)
  .succeeds()
 }
 
 pub fn main(cwd: &Path) -> CliAssert {
- CliAssert::command(&[
- "cargo", "run",
- "--manifest-path", cwd.join("Cargo.toml").to_str().unwrap(),
- ])
+ CliAssert::command(&["cargo", "run", "--manifest-path", cwd.join("Cargo.toml").to_str().unwrap()],)
 }
 
 pub fn binary(cwd: &Path, name: &str) -> CliAssert {
- CliAssert::command(&[
- "cargo", "run",
- "--manifest-path", cwd.join("Cargo.toml").to_str().unwrap(),
- "--bin", name,
- ])
+ CliAssert::command(
+ &[
+ "cargo",
+ "run",
+ "--manifest-path",
+ cwd.join("Cargo.toml").to_str().unwrap(),
+ "--bin",
+ name,
+ ],
+ )
 }
 
 fn cargo(cwd: &Path, subcommand: &str) -> CliAssert {
- CliAssert::command(&[
- "cargo", subcommand,
- "--manifest-path", cwd.join("Cargo.toml").to_str().unwrap(),
- ])
+ CliAssert::command(&["cargo", subcommand, "--manifest-path", cwd.join("Cargo.toml").to_str().unwrap()],)
 }
 
 pub fn cargo_check(cwd: &Path) -> CliAssert {
@@ -85,27 +80,25 @@ impl Assert {
  fn with_file(content: &str) -> Self {
  let a = Assert::default();
 
- create_dir_all(&a.output_dir)
- .expect("error creating output dir");
+ create_dir_all(&a.output_dir).expect("error creating output dir");
 
- let mut f = File::create(a.output_dir.join("test.md"))
- .expect("error create md file");
+ let mut f = File::create(a.output_dir.join("test.md")).expect("error create md file");
  f.write_all(unindent(content).as_bytes())
  .expect("error writing md file");
 
  a
  }
 
- pub fn running<F>(&self, cmd: F) -> &Self where
+ pub fn running<F>(&self, cmd: F) -> &Self
+ where
  F: for<'cwd> Fn(&'cwd Path) -> CliAssert,
  {
  cmd(&self.output_dir).unwrap();
  self
  }
 
  pub fn creates(&self, fa: FileAssert) -> &Self {
- fa.context(self.output_dir.to_owned())
- .unwrap();
+ fa.context(self.output_dir.to_owned()).unwrap();
  self
  }
 }
@@ -137,14 +130,16 @@ impl FileAssert {
  }
 
  fn unwrap(self) {
- let dir = self.working_dir.expect(&format!("No working dir set for `{}`", self.path));
+ let dir = self.working_dir
+ .expect(&format!("No working dir set for `{}`", self.path));
  let path = PathBuf::from(dir).join(&self.path);
 
  let mut f = File::open(&path).expect(&format!("no file at {:?}", path));
 
  if let Some(expected_content) = self.content {
  let mut content = String::new();
- f.read_to_string(&mut content).expect(&format!("failed to read {:?}", path));
+ f.read_to_string(&mut content)
+ .expect(&format!("failed to read {:?}", path));
 
  let diff = Changeset::new(&content, &unindent(&expected_content), "\n");
  if diff.distance > 0 {