organize use statements

src/bridge/create.rs

@@ -6,6 +6,7 @@ use std::{
     process::Stdio,
 };
 
+use nvim_rs::{error::LoopError, neovim::Neovim, Handler};
 use tokio::{
     io::split,
     net::{TcpStream, ToSocketAddrs},
@@ -13,8 +14,6 @@ use tokio::{
     spawn,
     task::JoinHandle,
 };
-
-use nvim_rs::{error::LoopError, neovim::Neovim, Handler};
 use tokio_util::compat::TokioAsyncReadCompatExt;
 
 use crate::bridge::{TxWrapper, WrapTx};

src/bridge/events.rs

@@ -1,7 +1,8 @@
-use std::convert::TryInto;
+use std::{
-use std::error;
+    convert::TryInto,
-use std::fmt;
+    error,
-use std::fmt::Debug;
+    fmt::{self, Debug},
+};
 
 use log::debug;
 use rmpv::Value;

src/bridge/handler.rs

@@ -4,14 +4,15 @@ use nvim_rs::{Handler, Neovim};
 use rmpv::Value;
 use tokio::task;
 
-use super::events::parse_redraw_event;
 #[cfg(windows)]
-use super::ui_commands::{ParallelCommand, UiCommand};
+use crate::bridge::ui_commands::{ParallelCommand, UiCommand};
-use crate::bridge::TxWrapper;
+use crate::{
-use crate::editor::EditorCommand;
+    bridge::{events::parse_redraw_event, TxWrapper},
-use crate::error_handling::ResultPanicExplanation;
+    editor::EditorCommand,
-use crate::event_aggregator::EVENT_AGGREGATOR;
+    error_handling::ResultPanicExplanation,
-use crate::settings::SETTINGS;
+    event_aggregator::EVENT_AGGREGATOR,
+    settings::SETTINGS,
+};
 
 #[derive(Clone)]
 pub struct NeovimHandler {}

src/bridge/mod.rs

@@ -4,19 +4,18 @@ mod handler;
 mod tx_wrapper;
 mod ui_commands;
 
-use std::path::Path;
+use std::{path::Path, process::Stdio, sync::Arc};
-use std::process::Stdio;
-use std::sync::Arc;
 
 use log::{error, info, warn};
 use nvim_rs::UiAttachOptions;
 use rmpv::Value;
-use tokio::process::Command;
+use tokio::{process::Command, runtime::Runtime};
-use tokio::runtime::Runtime;
+
+use crate::{
+    cmd_line::CmdLineSettings, error_handling::ResultPanicExplanation, running_tracker::*,
+    settings::*,
+};
 
-use crate::running_tracker::*;
-use crate::settings::*;
-use crate::{cmd_line::CmdLineSettings, error_handling::ResultPanicExplanation};
 pub use events::*;
 use handler::NeovimHandler;
 pub use tx_wrapper::{TxWrapper, WrapTx};

src/bridge/tx_wrapper.rs

@@ -1,7 +1,10 @@
+use std::{
+    io,
+    pin::Pin,
+    task::{Context, Poll},
+};
+
 use pin_project::pin_project;
-use std::io;
-use std::pin::Pin;
-use std::task::{Context, Poll};
 use tokio::{
     io::{AsyncWrite, WriteHalf},
     net::TcpStream,

src/bridge/ui_commands.rs

@@ -7,13 +7,13 @@ use log::trace;
 use nvim_rs::{call_args, rpc::model::IntoVal, Neovim};
 use tokio::sync::mpsc::unbounded_channel;
 
-use crate::bridge::TxWrapper;
-use crate::event_aggregator::EVENT_AGGREGATOR;
-use crate::running_tracker::RUNNING_TRACKER;
 #[cfg(windows)]
 use crate::windows_utils::{
     register_rightclick_directory, register_rightclick_file, unregister_rightclick,
 };
+use crate::{
+    bridge::TxWrapper, event_aggregator::EVENT_AGGREGATOR, running_tracker::RUNNING_TRACKER,
+};
 
 // Serial commands are any commands which must complete before the next value is sent. This
 // includes keyboard and mouse input which would cause problems if sent out of order.

src/channel_utils.rs

@@ -1,5 +1,7 @@
-use std::fmt::Debug;
+use std::{
-use std::sync::mpsc::{SendError, Sender};
+    fmt::Debug,
+    sync::mpsc::{SendError, Sender},
+};
 
 use log::trace;
 use tokio::sync::mpsc::{error::SendError as TokioSendError, UnboundedSender};

src/cmd_line.rs

@@ -1,5 +1,4 @@
-use crate::settings::*;
+use crate::{dimensions::Dimensions, settings::*};
-use crate::utils::Dimensions;
 
 use clap::{App, Arg};
 

src/dimensions.rs

@@ -1,6 +1,7 @@
+use std::ops::{Div, Mul};
+
 use glutin::dpi::PhysicalSize;
 use serde::{Deserialize, Serialize};
-use std::ops::{Div, Mul};
 
 // Maybe this should be independent from serialization?
 #[derive(Debug, Clone, Copy, Eq, PartialEq, Serialize, Deserialize)]

src/editor/cursor.rs

@@ -1,9 +1,8 @@
-use std::collections::HashMap;
+use std::{collections::HashMap, sync::Arc};
-use std::sync::Arc;
 
 use skia_safe::Color4f;
 
-use super::style::{Colors, Style};
+use crate::editor::style::{Colors, Style};
 
 #[derive(Debug, Clone, PartialEq)]
 pub enum CursorShape {

src/editor/draw_command_batcher.rs

@@ -1,7 +1,6 @@
 use std::sync::mpsc::{channel, Receiver, SendError, Sender};
 
-use super::DrawCommand;
+use crate::{editor::DrawCommand, event_aggregator::EVENT_AGGREGATOR};
-use crate::event_aggregator::EVENT_AGGREGATOR;
 
 pub struct DrawCommandBatcher {
     window_draw_command_sender: Sender<DrawCommand>,

src/editor/grid.rs

@@ -1,6 +1,6 @@
 use std::sync::Arc;
 
-use super::style::Style;
+use crate::editor::style::Style;
 
 pub type GridCell = (String, Option<Arc<Style>>);
 

src/editor/mod.rs

@@ -4,17 +4,18 @@ mod grid;
 mod style;
 mod window;
 
-use std::collections::HashMap;
+use std::{collections::HashMap, sync::Arc, thread};
-use std::sync::Arc;
-use std::thread;
 
 use log::{error, trace};
 
-use crate::bridge::{GuiOption, RedrawEvent, WindowAnchor};
+use crate::{
-use crate::event_aggregator::EVENT_AGGREGATOR;
+    bridge::{GuiOption, RedrawEvent, WindowAnchor},
-use crate::redraw_scheduler::REDRAW_SCHEDULER;
+    event_aggregator::EVENT_AGGREGATOR,
-use crate::renderer::DrawCommand;
+    redraw_scheduler::REDRAW_SCHEDULER,
-use crate::window::WindowCommand;
+    renderer::DrawCommand,
+    window::WindowCommand,
+};
+
 pub use cursor::{Cursor, CursorMode, CursorShape};
 pub use draw_command_batcher::DrawCommandBatcher;
 pub use grid::CharacterGrid;

src/editor/window.rs

@@ -1,14 +1,13 @@
-use std::collections::HashMap;
+use std::{collections::HashMap, sync::Arc};
-use std::sync::Arc;
 
 use log::warn;
 use unicode_segmentation::UnicodeSegmentation;
 
-use super::grid::CharacterGrid;
+use crate::{
-use super::style::Style;
+    bridge::GridLineCell,
-use super::{AnchorInfo, DrawCommand, DrawCommandBatcher};
+    editor::{grid::CharacterGrid, style::Style, AnchorInfo, DrawCommand, DrawCommandBatcher},
-use crate::bridge::GridLineCell;
+    renderer::{LineFragment, WindowDrawCommand},
-use crate::renderer::{LineFragment, WindowDrawCommand};
+};
 
 pub enum WindowType {
     Editor,

src/event_aggregator.rs

@@ -1,6 +1,8 @@
-use std::any::{type_name, Any, TypeId};
+use std::{
-use std::collections::{hash_map::Entry, HashMap};
+    any::{type_name, Any, TypeId},
-use std::fmt::Debug;
+    collections::{hash_map::Entry, HashMap},
+    fmt::Debug,
+};
 
 use parking_lot::{Mutex, RwLock};
 use tokio::sync::mpsc::{unbounded_channel, UnboundedReceiver};

src/main.rs

@@ -1,8 +1,5 @@
 #![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]
 
-#[cfg(not(test))]
-use flexi_logger::{Cleanup, Criterion, Duplicate, Logger, Naming};
-
 // Test naming occasionally uses camelCase with underscores to separate sections of
 // the test name.
 #[cfg_attr(test, allow(non_snake_case))]
@@ -15,6 +12,7 @@ extern crate clap;
 mod bridge;
 mod channel_utils;
 mod cmd_line;
+mod dimensions;
 mod editor;
 mod error_handling;
 mod event_aggregator;
@@ -22,7 +20,6 @@ mod redraw_scheduler;
 mod renderer;
 mod running_tracker;
 mod settings;
-mod utils;
 mod window;
 mod windows_utils;
 
@@ -33,6 +30,8 @@ extern crate lazy_static;
 
 use std::env::args;
 
+#[cfg(not(test))]
+use flexi_logger::{Cleanup, Criterion, Duplicate, Logger, Naming};
 use log::trace;
 
 use bridge::start_bridge;

src/redraw_scheduler.rs

@@ -1,6 +1,10 @@
-use std::sync::atomic::{AtomicBool, Ordering};
+use std::{
-use std::sync::Mutex;
+    sync::{
-use std::time::Instant;
+        atomic::{AtomicBool, Ordering},
+        Mutex,
+    },
+    time::Instant,
+};
 
 use log::trace;
 

src/renderer/cursor_renderer/blink.rs

@@ -1,7 +1,6 @@
 use std::time::{Duration, Instant};
 
-use crate::editor::Cursor;
+use crate::{editor::Cursor, redraw_scheduler::REDRAW_SCHEDULER};
-use crate::redraw_scheduler::REDRAW_SCHEDULER;
 
 #[derive(Debug)]
 pub enum BlinkState {

src/renderer/cursor_renderer/cursor_vfx.rs

@@ -1,10 +1,13 @@
 use log::error;
+use nvim_rs::Value;
 use skia_safe::{paint::Style, BlendMode, Canvas, Color, Paint, Point, Rect};
 
-use super::CursorSettings;
+use crate::{
-use crate::editor::Cursor;
+    editor::Cursor,
-use crate::renderer::{animation_utils::*, grid_renderer::GridRenderer};
+    renderer::cursor_renderer::CursorSettings,
-use crate::settings::*;
+    renderer::{animation_utils::*, grid_renderer::GridRenderer},
+    settings::*,
+};
 
 pub trait CursorVfx {
     fn update(

src/renderer/cursor_renderer/mod.rs

@@ -3,15 +3,16 @@ mod cursor_vfx;
 
 use std::collections::HashMap;
 
-// use neovide_derive::SettingGroup;
 use skia_safe::{Canvas, Paint, Path, Point};
 
-use super::{GridRenderer, RenderedWindow};
+use crate::{
-use crate::bridge::EditorMode;
+    bridge::EditorMode,
-use crate::editor::{Cursor, CursorShape};
+    editor::{Cursor, CursorShape},
-use crate::redraw_scheduler::REDRAW_SCHEDULER;
+    redraw_scheduler::REDRAW_SCHEDULER,
-use crate::renderer::animation_utils::*;
+    renderer::animation_utils::*,
-use crate::settings::{FromValue, SETTINGS};
+    renderer::{GridRenderer, RenderedWindow},
+    settings::{FromValue, SETTINGS},
+};
 
 use blink::*;
 

src/renderer/fonts/caching_shaper.rs

@@ -3,14 +3,17 @@ use std::sync::Arc;
 use log::trace;
 use lru::LruCache;
 use skia_safe::{TextBlob, TextBlobBuilder};
-use swash::shape::ShapeContext;
+use swash::{
-use swash::text::cluster::{CharCluster, Parser, Status, Token};
+    shape::ShapeContext,
-use swash::text::Script;
+    text::{
-use swash::Metrics;
+        cluster::{CharCluster, Parser, Status, Token},
+        Script,
+    },
+    Metrics,
+};
 use unicode_segmentation::UnicodeSegmentation;
 
-use super::font_loader::*;
+use crate::renderer::fonts::{font_loader::*, font_options::*};
-use super::font_options::*;
 
 #[derive(new, Clone, Hash, PartialEq, Eq, Debug)]
 struct ShapeKey {

src/renderer/fonts/font_loader.rs

@@ -3,8 +3,7 @@ use std::sync::Arc;
 use lru::LruCache;
 use skia_safe::{font::Edging, Data, Font, FontHinting, FontMgr, FontStyle, Typeface};
 
-use super::font_options::FontOptions;
+use crate::renderer::fonts::{font_options::FontOptions, swash_font::SwashFont};
-use super::swash_font::SwashFont;
 
 static DEFAULT_FONT: &[u8] = include_bytes!("../../../assets/fonts/FiraCode-Regular.ttf");
 static LAST_RESORT_FONT: &[u8] = include_bytes!("../../../assets/fonts/LastResort-Regular.ttf");

src/renderer/grid_renderer.rs

@@ -4,11 +4,13 @@ use glutin::dpi::PhysicalSize;
 use log::trace;
 use skia_safe::{colors, dash_path_effect, BlendMode, Canvas, Color, Paint, Rect, HSV};
 
-use super::{CachingShaper, RendererSettings};
+use crate::{
-use crate::editor::{Colors, Style};
+    dimensions::Dimensions,
-use crate::settings::*;
+    editor::{Colors, Style},
-use crate::utils::Dimensions;
+    renderer::{CachingShaper, RendererSettings},
-use crate::window::WindowSettings;
+    settings::*,
+    window::WindowSettings,
+};
 
 pub struct GridRenderer {
     pub shaper: CachingShaper,

src/renderer/mod.rs

@@ -4,19 +4,24 @@ mod fonts;
 pub mod grid_renderer;
 mod rendered_window;
 
-use crate::WindowSettings;
+use std::{
-use std::cmp::Ordering;
+    cmp::Ordering,
-use std::collections::{hash_map::Entry, HashMap};
+    collections::{hash_map::Entry, HashMap},
-use std::sync::Arc;
+    sync::Arc,
+};
 
 use log::error;
 use skia_safe::Canvas;
 use tokio::sync::mpsc::UnboundedReceiver;
 
-use crate::bridge::EditorMode;
+use crate::{
-use crate::editor::{Cursor, Style};
+    bridge::EditorMode,
-use crate::event_aggregator::EVENT_AGGREGATOR;
+    editor::{Cursor, Style},
-use crate::settings::*;
+    event_aggregator::EVENT_AGGREGATOR,
+    settings::*,
+    WindowSettings,
+};
+
 use cursor_renderer::CursorRenderer;
 pub use fonts::caching_shaper::CachingShaper;
 pub use grid_renderer::GridRenderer;

src/renderer/rendered_window.rs

@@ -1,18 +1,19 @@
-use std::collections::VecDeque;
+use std::{collections::VecDeque, sync::Arc};
-use std::sync::Arc;
 
-use skia_safe::canvas::{SaveLayerRec, SrcRectConstraint};
-use skia_safe::gpu::SurfaceOrigin;
 use skia_safe::{
-    image_filters::blur, BlendMode, Budgeted, Canvas, Color, Image, ImageInfo, Paint, Point, Rect,
+    canvas::{SaveLayerRec, SrcRectConstraint},
-    SamplingOptions, Surface, SurfaceProps, SurfacePropsFlags,
+    gpu::SurfaceOrigin,
+    image_filters::blur,
+    BlendMode, Budgeted, Canvas, Color, Image, ImageInfo, Paint, Point, Rect, SamplingOptions,
+    Surface, SurfaceProps, SurfacePropsFlags,
 };
 
-use super::animation_utils::*;
+use crate::{
-use super::{GridRenderer, RendererSettings};
+    dimensions::Dimensions,
-use crate::editor::Style;
+    editor::Style,
-use crate::redraw_scheduler::REDRAW_SCHEDULER;
+    redraw_scheduler::REDRAW_SCHEDULER,
-use crate::utils::Dimensions;
+    renderer::{animation_utils::*, GridRenderer, RendererSettings},
+};
 
 #[derive(Clone, Debug)]
 pub struct LineFragment {

src/settings/mod.rs

@@ -1,22 +1,23 @@
-use std::any::{Any, TypeId};
-use std::collections::HashMap;
-use std::convert::TryInto;
-
 mod from_value;
 mod window_geometry;
-pub use from_value::FromValue;
+
 use log::trace;
 use nvim_rs::Neovim;
 use parking_lot::RwLock;
-pub use rmpv::Value;
+use rmpv::Value;
+use std::{
+    any::{Any, TypeId},
+    collections::HashMap,
+    convert::TryInto,
+};
+
+use crate::{bridge::TxWrapper, error_handling::ResultPanicExplanation};
+pub use from_value::FromValue;
 pub use window_geometry::{
     load_last_window_settings, parse_window_geometry, save_window_geometry,
     PersistentWindowSettings, DEFAULT_WINDOW_GEOMETRY,
 };
 
-use crate::bridge::TxWrapper;
-use crate::error_handling::ResultPanicExplanation;
-
 lazy_static! {
     pub static ref SETTINGS: Settings = Settings::new();
 }

src/settings/window_geometry.rs

@@ -1,9 +1,9 @@
-use crate::settings::SETTINGS;
+use std::path::PathBuf;
-use crate::utils::Dimensions;
+
-use crate::window::WindowSettings;
 use glutin::dpi::PhysicalPosition;
 use serde::{Deserialize, Serialize};
-use std::path::PathBuf;
+
+use crate::{dimensions::Dimensions, settings::SETTINGS, window::WindowSettings};
 
 const SETTINGS_FILE: &str = "neovide-settings.json";
 

src/utils/mod.rs

@@ -1,3 +0,0 @@
-mod dimensions;
-
-pub use dimensions::*;

src/window/keyboard_manager.rs

@@ -1,13 +1,15 @@
-use glutin::event::{ElementState, Event, KeyEvent, WindowEvent};
+use glutin::{
-use glutin::keyboard::Key;
+    event::{ElementState, Event, KeyEvent, WindowEvent},
-use glutin::keyboard::Key::Dead;
+    keyboard::{Key, Key::Dead},
-
+    platform::modifier_supplement::KeyEventExtModifierSupplement,
-use glutin::platform::modifier_supplement::KeyEventExtModifierSupplement;
+};
-
+
-use crate::bridge::{SerialCommand, UiCommand};
+use crate::{
-use crate::event_aggregator::EVENT_AGGREGATOR;
+    bridge::{SerialCommand, UiCommand},
-use crate::settings::SETTINGS;
+    event_aggregator::EVENT_AGGREGATOR,
-use crate::window::KeyboardSettings;
+    settings::SETTINGS,
+    window::KeyboardSettings,
+};
 
 enum InputEvent {
     KeyEvent(KeyEvent),
@@ -89,8 +91,9 @@ impl KeyboardManager {
                                 // And a key was pressed
                                 if key_event.state == ElementState::Pressed {
                                     if let Some(keybinding) = self.maybe_get_keybinding(key_event) {
-                                        EVENT_AGGREGATOR
+                                        EVENT_AGGREGATOR.send(UiCommand::Serial(
-                                            .send(UiCommand::Serial(SerialCommand::Keyboard(keybinding)));
+                                            SerialCommand::Keyboard(keybinding),
+                                        ));
                                     }
                                     next_dead_key = None;
                                 } else if key_event.state == ElementState::Released {
@@ -103,8 +106,9 @@ impl KeyboardManager {
                             }
                             InputEvent::ImeInput(raw_input) => {
                                 if self.prev_dead_key.is_none() {
-                                    EVENT_AGGREGATOR
+                                    EVENT_AGGREGATOR.send(UiCommand::Serial(
-                                        .send(UiCommand::Serial(SerialCommand::Keyboard(raw_input.to_string())));
+                                        SerialCommand::Keyboard(raw_input.to_string()),
+                                    ));
                                 }
                             }
                         }

src/window/mod.rs

@@ -27,6 +27,7 @@ use renderer::SkiaRenderer;
 use crate::{
     bridge::{ParallelCommand, UiCommand},
     cmd_line::CmdLineSettings,
+    dimensions::Dimensions,
     editor::EditorCommand,
     event_aggregator::EVENT_AGGREGATOR,
     redraw_scheduler::REDRAW_SCHEDULER,
@@ -35,7 +36,6 @@ use crate::{
     settings::{
         load_last_window_settings, save_window_geometry, PersistentWindowSettings, SETTINGS,
     },
-    utils::Dimensions,
 };
 pub use settings::{KeyboardSettings, WindowSettings};
 

src/window/mouse_manager.rs

@@ -8,12 +8,14 @@ use glutin::{
 };
 use skia_safe::Rect;
 
-use super::keyboard_manager::KeyboardManager;
+use crate::{
-use crate::bridge::{SerialCommand, UiCommand};
+    bridge::{SerialCommand, UiCommand},
-use crate::event_aggregator::EVENT_AGGREGATOR;
+    event_aggregator::EVENT_AGGREGATOR,
-use crate::renderer::{Renderer, WindowDrawDetails};
+    renderer::{Renderer, WindowDrawDetails},
-use crate::settings::SETTINGS;
+    settings::SETTINGS,
-use crate::window::WindowSettings;
+    window::keyboard_manager::KeyboardManager,
+    window::WindowSettings,
+};
 
 fn clamp_position(
     position: PhysicalPosition<f32>,

src/window/renderer.rs

@@ -1,9 +1,11 @@
-use skia_safe::gpu::gl::FramebufferInfo;
-use skia_safe::gpu::{BackendRenderTarget, DirectContext, SurfaceOrigin};
-use skia_safe::{Canvas, ColorType, Surface};
 use std::convert::TryInto;
 
 use gl::types::*;
+use skia_safe::{
+    gpu::{gl::FramebufferInfo, BackendRenderTarget, DirectContext, SurfaceOrigin},
+    Canvas, ColorType, Surface,
+};
+
 type WindowedContext = glutin::ContextWrapper<glutin::PossiblyCurrent, glutin::window::Window>;
 
 fn create_surface(

src/windows_utils.rs

@@ -1,7 +1,7 @@
 #[cfg(target_os = "windows")]
-use {
+use std::{
-    std::ffi::CString,
+    ffi::CString,
-    std::ptr::{null, null_mut},
+    ptr::{null, null_mut},
 };
 
 #[cfg(windows)]