Remove lazy static dependency (#1174)

* deps: remove lazy_static from dependencies

* fix: clippy

Author: sftse

Cargo.lock

@@ -39,9 +39,9 @@ x11 = [ "dep:gdkx11-sys", "dep:x11-dl" ]
 members = [ "tao-macros" ]
 
 [dependencies]
-lazy_static = "1"
 libc = "0.2"
 log = "0.4"
+once_cell = "1"
 serde = { version = "1", optional = true, features = [ "serde_derive" ] }
 rwh_04 = { package = "raw-window-handle", version = "0.4", optional = true }
 rwh_05 = { package = "raw-window-handle", version = "0.5", features = [ "std" ], optional = true }
@@ -96,9 +96,6 @@ windows-core = "0.61"
   "Win32_UI_WindowsAndMessaging"
 ]
 
-[target."cfg(any(target_os = \"android\", target_os = \"windows\"))".dependencies]
-once_cell = "1"
-
 [target."cfg(target_os = \"android\")".dependencies]
 jni = "0.21"
 ndk = "0.9"

Cargo.toml

@@ -30,7 +30,7 @@ fn main() {
 
       if let Event::WindowEvent { event, .. } = &event {
         // Print only Window events to reduce noise
-        println!("{:?}", event);
+        println!("{event:?}");
       }
 
       match event {

examples/window_run_return.rs

@@ -112,6 +112,16 @@ impl<T> EventLoopBuilder<T> {
   #[inline]
   pub fn build(&mut self) -> EventLoop<T> {
     EventLoop {
+      #[cfg_attr(
+        any(
+          target_os = "linux",
+          target_os = "dragonfly",
+          target_os = "freebsd",
+          target_os = "netbsd",
+          target_os = "openbsd"
+        ),
+        allow(clippy::unnecessary_mut_passed)
+      )]
       event_loop: platform_impl::EventLoop::new(&mut self.platform_specific),
       _marker: PhantomData,
     }

src/event_loop.rs

@@ -155,9 +155,6 @@ pub use rwh_05;
 #[cfg(feature = "rwh_06")]
 pub use rwh_06;
 
-#[allow(unused_imports)]
-#[macro_use]
-extern crate lazy_static;
 #[allow(unused_imports)]
 #[macro_use]
 extern crate log;

src/lib.rs

@@ -106,7 +106,7 @@ impl WindowExtUnix for Window {
     window: gtk::ApplicationWindow,
   ) -> Result<Window, OsError> {
     let window = UnixWindow::new_from_gtk_window(&event_loop_window_target.p, window)?;
-    Ok(Window { window: window })
+    Ok(Window { window })
   }
 
   fn set_badge_count(&self, count: Option<i64>, desktop_filename: Option<String>) {

src/platform/unix.rs

@@ -17,6 +17,7 @@ use ndk::{
   event::{InputEvent, KeyAction, MotionAction},
   looper::{ForeignLooper, Poll, ThreadLooper},
 };
+use once_cell::sync::Lazy;
 use std::{
   collections::VecDeque,
   sync::RwLock,
@@ -26,9 +27,7 @@ use std::{
 pub mod ndk_glue;
 use ndk_glue::{Event, Rect};
 
-lazy_static! {
-  static ref CONFIG: RwLock<Configuration> = RwLock::new(Configuration::new());
-}
+static CONFIG: Lazy<RwLock<Configuration>> = Lazy::new(|| RwLock::new(Configuration::new()));
 
 enum EventSource {
   Callback,

src/platform_impl/android/mod.rs

@@ -14,6 +14,7 @@ use std::{
 };
 
 use objc2::runtime::AnyObject;
+use once_cell::sync::Lazy;
 
 use crate::{
   dpi::LogicalSize,
@@ -1005,29 +1006,24 @@ impl NSOperatingSystemVersion {
 }
 
 pub fn os_capabilities() -> OSCapabilities {
-  lazy_static! {
-      static ref OS_CAPABILITIES: OSCapabilities = {
-          let version: NSOperatingSystemVersion = unsafe {
-              let process_info: id = msg_send![class!(NSProcessInfo), processInfo];
-              let atleast_ios_8: bool = msg_send![
-                  process_info,
-                  respondsToSelector: sel!(operatingSystemVersion)
-              ];
-              // tao requires atleast iOS 8 because no one has put the time into supporting earlier os versions.
-              // Older iOS versions are increasingly difficult to test. For example, Xcode 11 does not support
-              // debugging on devices with an iOS version of less than 8. Another example, in order to use an iOS
-              // simulator older than iOS 8, you must download an older version of Xcode (<9), and at least Xcode 7
-              // has been tested to not even run on macOS 10.15 - Xcode 8 might?
-              //
-              // The minimum required iOS version is likely to grow in the future.
-              assert!(
-                  atleast_ios_8,
-                  "`tao` requires iOS version 8 or greater"
-              );
-              msg_send![process_info, operatingSystemVersion]
-          };
-          version.into()
-      };
-  }
+  static OS_CAPABILITIES: Lazy<OSCapabilities> = Lazy::new(|| {
+    let version: NSOperatingSystemVersion = unsafe {
+      let process_info: id = msg_send![class!(NSProcessInfo), processInfo];
+      let atleast_ios_8: bool = msg_send![
+          process_info,
+          respondsToSelector: sel!(operatingSystemVersion)
+      ];
+      // tao requires atleast iOS 8 because no one has put the time into supporting earlier os versions.
+      // Older iOS versions are increasingly difficult to test. For example, Xcode 11 does not support
+      // debugging on devices with an iOS version of less than 8. Another example, in order to use an iOS
+      // simulator older than iOS 8, you must download an older version of Xcode (<9), and at least Xcode 7
+      // has been tested to not even run on macOS 10.15 - Xcode 8 might?
+      //
+      // The minimum required iOS version is likely to grow in the future.
+      assert!(atleast_ios_8, "`tao` requires iOS version 8 or greater");
+      msg_send![process_info, operatingSystemVersion]
+    };
+    version.into()
+  });
   OS_CAPABILITIES.clone()
 }

src/platform_impl/ios/app_state.rs

@@ -45,35 +45,32 @@ pub fn spawn(device_tx: glib::Sender<DeviceEvent>) {
       }
 
       let event_type = event.get_type();
-      match event_type {
-        xlib::GenericEvent => {
-          let mut xev = event.generic_event_cookie;
-          if (xlib.XGetEventData)(display, &mut xev) == xlib::True {
-            match xev.evtype {
-              xinput2::XI_RawKeyPress | xinput2::XI_RawKeyRelease => {
-                let xev: &xinput2::XIRawEvent = &*(xev.data as *const _);
-                let physical_key = keycode_from_scancode(xev.detail as u32);
-                let state = match xev.evtype {
-                  xinput2::XI_RawKeyPress => ElementState::Pressed,
-                  xinput2::XI_RawKeyRelease => ElementState::Released,
-                  _ => unreachable!(),
-                };
+      if event_type == xlib::GenericEvent {
+        let mut xev = event.generic_event_cookie;
+        if (xlib.XGetEventData)(display, &mut xev) == xlib::True {
+          match xev.evtype {
+            xinput2::XI_RawKeyPress | xinput2::XI_RawKeyRelease => {
+              let xev: &xinput2::XIRawEvent = &*(xev.data as *const _);
+              let physical_key = keycode_from_scancode(xev.detail as u32);
+              let state = match xev.evtype {
+                xinput2::XI_RawKeyPress => ElementState::Pressed,
+                xinput2::XI_RawKeyRelease => ElementState::Released,
+                _ => unreachable!(),
+              };
 
-                let event = RawKeyEvent {
-                  physical_key,
-                  state,
-                };
+              let event = RawKeyEvent {
+                physical_key,
+                state,
+              };
 
-                if let Err(e) = device_tx.send(DeviceEvent::Key(event)) {
-                  log::info!("Failed to send device event {} since receiver is closed. Closing x11 thread along with it", e);
-                  break;
-                }
+              if let Err(e) = device_tx.send(DeviceEvent::Key(event)) {
+                log::info!("Failed to send device event {} since receiver is closed. Closing x11 thread along with it", e);
+                break;
               }
-              _ => {}
             }
+            _ => {}
           }
         }
-        _ => {}
       }
     }
   });

src/platform_impl/linux/device.rs

@@ -87,9 +87,8 @@ impl<T> EventLoopWindowTarget<T> {
   #[inline]
   pub fn primary_monitor(&self) -> Option<RootMonitorHandle> {
     let monitor = self.display.primary_monitor();
-    monitor.and_then(|monitor| {
-      let handle = MonitorHandle { monitor };
-      Some(RootMonitorHandle { inner: handle })
+    monitor.map(|monitor| RootMonitorHandle {
+      inner: MonitorHandle { monitor },
     })
   }
 
@@ -910,7 +909,7 @@ impl<T: 'static> EventLoop<T> {
                 let background_color = unsafe {
                   window
                     .data::<Option<crate::window::RGBA>>("background_color")
-                    .and_then(|c| c.as_ref().clone())
+                    .and_then(|c| *c.as_ref())
                 };
 
                 let rgba = background_color
@@ -1010,7 +1009,7 @@ impl<T: 'static> EventLoop<T> {
   /// There are a dew notibale event will sent to callback when state is transisted:
   /// - On any state moves to `LoopDestroyed`, a `LoopDestroyed` event is sent.
   /// - On `NewStart` to `EventQueue`, a `NewEvents` with corresponding `StartCause` depends on
-  /// current control flow is sent.
+  ///   current control flow is sent.
   /// - On `EventQueue` to `DrawQueue`, a `MainEventsCleared` event is sent.
   /// - On `DrawQueue` back to `NewStart`, a `RedrawEventsCleared` event is sent.
   pub(crate) fn run_return<F>(&mut self, mut callback: F) -> i32
@@ -1097,7 +1096,7 @@ impl<T: 'static> EventLoop<T> {
             EventState::EventQueue => match control_flow {
               ControlFlow::ExitWithCode(code) => {
                 callback(Event::LoopDestroyed, window_target, &mut control_flow);
-                break (code);
+                break code;
               }
               _ => match events.try_recv() {
                 Ok(event) => match event {