rustfmt

build.rs

@@ -4,9 +4,7 @@ use std::path::PathBuf;
 fn main() {
     let mut mdbook_files = skeptic::markdown_files_of_directory("docs/guides/");
 
-    let other_files: Vec<PathBuf> = vec![
-        "README.md".into(),
-    ];
+    let other_files: Vec<PathBuf> = vec!["README.md".into()];
     mdbook_files.extend(other_files);
     skeptic::generate_doc_tests(&mdbook_files);
 }

examples/01_super_simple.rs

@@ -52,7 +52,7 @@ pub fn main() -> GameResult {
     } else {
         path::PathBuf::from("./resources")
     };
-    
+
     let cb = ggez::ContextBuilder::new("bunnymark", "ggez").add_resource_path(resource_dir);
     let (ctx, event_loop) = &mut cb.build()?;
     let state = &mut MainState::new(ctx)?;

examples/05_astroblasto.rs

@@ -2,7 +2,6 @@
 //! The idea is that this game is simple but still
 //! non-trivial enough to be interesting.
 
-use rand;
 use ggez;
 use ggez::audio;
 use ggez::audio::SoundSource;
@@ -12,6 +11,7 @@ use ggez::graphics;
 use ggez::nalgebra as na;
 use ggez::timer;
 use ggez::{Context, ContextBuilder, GameResult};
+use rand;
 
 use std::env;
 use std::path;

examples/bunnymark.rs

@@ -4,13 +4,13 @@
 use std::env;
 use std::path;
 
+use nalgebra as na;
 use rand::rngs::ThreadRng;
 use rand::{self, Rng};
-use nalgebra as na;
 
-use ggez::*;
-use ggez::graphics::{Color, Image, spritebatch::SpriteBatch};
+use ggez::graphics::{spritebatch::SpriteBatch, Color, Image};
 use ggez::Context;
+use ggez::*;
 
 // NOTE: Using a high number here yields worse performance than adding more bunnies over
 // time - I think this is due to all of the RNG being run on the same tick...
@@ -116,12 +116,12 @@ impl event::EventHandler for GameState {
         if self.batched_drawing {
             self.bunnybatch.clear();
             for bunny in &self.bunnies {
-                self.bunnybatch.add((bunny.position, ));
+                self.bunnybatch.add((bunny.position,));
             }
-            graphics::draw(ctx, &self.bunnybatch, (na::Point2::new(0.0, 0.0), ))?;
+            graphics::draw(ctx, &self.bunnybatch, (na::Point2::new(0.0, 0.0),))?;
         } else {
             for bunny in &self.bunnies {
-                graphics::draw(ctx, &self.texture, (bunny.position, ))?;
+                graphics::draw(ctx, &self.texture, (bunny.position,))?;
             }
         }
 
@@ -139,25 +139,32 @@ impl event::EventHandler for GameState {
         Ok(())
     }
 
-    fn key_down_event(&mut self, _ctx: &mut Context,
-                      keycode: event::KeyCode, _keymods: event::KeyMods, _repeat: bool) {
+    fn key_down_event(
+        &mut self,
+        _ctx: &mut Context,
+        keycode: event::KeyCode,
+        _keymods: event::KeyMods,
+        _repeat: bool,
+    ) {
         if keycode == event::KeyCode::Space {
             self.batched_drawing = !self.batched_drawing;
         }
     }
 
-    fn mouse_button_down_event(&mut self, _ctx: &mut Context,
-                               button: input::mouse::MouseButton,
-                               _x: f32,
-                               _y: f32) {
+    fn mouse_button_down_event(
+        &mut self,
+        _ctx: &mut Context,
+        button: input::mouse::MouseButton,
+        _x: f32,
+        _y: f32,
+    ) {
         if button == input::mouse::MouseButton::Left && self.click_timer == 0 {
             for _ in 0..INITIAL_BUNNIES {
                 self.bunnies.push(Bunny::new(&mut self.rng));
             }
             self.click_timer = 10;
         }
     }
-
 }
 
 fn main() -> GameResult {

src/context.rs

@@ -170,7 +170,7 @@ impl Context {
                     self.mouse_context
                         .set_last_delta(Point2::new(x as f32, y as f32));
                 }
-            },
+            }
 
             _ => (),
         };

src/graphics/mesh.rs

@@ -188,7 +188,9 @@ impl MeshBuilder {
         P: Into<mint::Point2<f32>> + Clone,
     {
         if points.len() < 2 {
-            return Err(GameError::LyonError("MeshBuilder::polyline() got a list of < 2 points".to_string()))
+            return Err(GameError::LyonError(
+                "MeshBuilder::polyline() got a list of < 2 points".to_string(),
+            ));
         }
 
         self.polyline_inner(mode, points, false, color)
@@ -207,7 +209,9 @@ impl MeshBuilder {
         P: Into<mint::Point2<f32>> + Clone,
     {
         if points.len() < 3 {
-            return Err(GameError::LyonError("MeshBuilder::polygon() got a list of < 3 points".to_string()))
+            return Err(GameError::LyonError(
+                "MeshBuilder::polygon() got a list of < 3 points".to_string(),
+            ));
         }
 
         self.polyline_inner(mode, points, true, color)
@@ -366,7 +370,6 @@ impl MeshBuilder {
             return Err(GameError::LyonError(msg));
         }
 
-
         let (vbuf, slice) = ctx
             .gfx_context
             .factory
@@ -506,7 +509,9 @@ impl Mesh {
         P: Into<mint::Point2<f32>> + Clone,
     {
         if points.len() < 3 {
-            return Err(GameError::LyonError("Mesh::new_polygon() got a list of < 3 points".to_string()))
+            return Err(GameError::LyonError(
+                "Mesh::new_polygon() got a list of < 3 points".to_string(),
+            ));
         }
         let mut mb = MeshBuilder::new();
         let _ = mb.polygon(mode, points, color);

src/lib.rs

@@ -54,7 +54,7 @@
 //! struct MyGame {
 //!     // Your state here...
 //! }
-//! 
+//!
 //! impl MyGame {
 //!     pub fn new(_ctx: &mut Context) -> MyGame {
 //!         // Load/create resources such as images here.
@@ -77,7 +77,7 @@
 //!         graphics::present(ctx)
 //!     }
 //! }
-//! 
+//!
 //! ```
 
 #![deny(missing_docs)]

src/tests/graphics.rs

@@ -72,4 +72,3 @@ fn test_transform_stack_order() {
     let m2: crate::nalgebra::Matrix4<f32> = t2.into();
     assert_eq!(res, m2 * m1);
 }
-