Rename OnReady::node(...) -> from_node(...)

Also rename internal module files.

Author: Bromeon

godot-core/src/obj/mod.rs

@@ -16,8 +16,8 @@ mod dyn_gd;
 mod gd;
 mod guards;
 mod instance_id;
-mod oneditor;
-mod onready;
+mod on_editor;
+mod on_ready;
 mod raw_gd;
 mod traits;
 
@@ -28,8 +28,8 @@ pub use dyn_gd::DynGd;
 pub use gd::*;
 pub use guards::{BaseMut, BaseRef, DynGdMut, DynGdRef, GdMut, GdRef};
 pub use instance_id::*;
-pub use oneditor::*;
-pub use onready::*;
+pub use on_editor::*;
+pub use on_ready::*;
 pub use raw_gd::*;
 pub use traits::*;
 

godot-core/src/obj/oneditor.rs renamed to godot-core/src/obj/on_editor.rs

@@ -21,7 +21,7 @@ use crate::registry::property::{BuiltinExport, Export, Var};
 /// `OnEditor<T>` should always be used as a property, preferably in tandem with an `#[export]` or `#[var]`.
 /// Initializing `OnEditor` values via code before the first use is supported but should be limited to use cases involving builder or factory patterns.
 ///
-/// [`Option<Gd<T>>`](std::option) and [`OnReady<Gd<T>>`](crate::obj::onready::OnReady) should be used for any other late initialization logic.
+/// [`Option<Gd<T>>`](std::option) and [`OnReady<Gd<T>>`](crate::obj::on_ready::OnReady) should be used for any other late initialization logic.
 ///
 /// # Using `OnEditor<T>` with `Gd<T>` and `DynGd<T, D>`
 ///

godot-core/src/obj/onready.rs renamed to godot-core/src/obj/on_ready.rs

@@ -22,7 +22,7 @@ use std::mem;
 /// `OnReady<T>` should always be used as a field. There are two modes to use it:
 ///
 /// 1. **Automatic mode, using [`new()`](OnReady::new), [`from_base_fn()`](OnReady::from_base_fn) or
-///    [`node()`](OnReady::<Gd<T>>::node).**<br>
+///    [`node()`](OnReady::<Gd<T>>::from_node).**<br>
 ///    Before `ready()` is called, all `OnReady` fields constructed with the above methods are automatically initialized,
 ///    in the order of declaration. This means that you can safely access them in `ready()`.<br><br>
 /// 2. **Manual mode, using [`manual()`](Self::manual).**<br>
@@ -86,8 +86,10 @@ use std::mem;
 /// #[class(init, base = Node)]
 /// struct MyClass {
 ///    base: Base<Node>,
+///
 ///    #[init(node = "ChildPath")]
 ///    auto: OnReady<Gd<Node2D>>,
+///
 ///    #[init(val = OnReady::manual())]
 ///    manual: OnReady<i32>,
 /// }
@@ -119,11 +121,16 @@ impl<T: GodotClass + Inherits<Node>> OnReady<Gd<T>> {
     ///
     /// Note that the panic will only happen if and when the node enters the SceneTree for the first time
     ///  (i.e.: it receives the `READY` notification).
-    pub fn node(path: impl AsArg<NodePath>) -> Self {
+    pub fn from_node(path: impl AsArg<NodePath>) -> Self {
         arg_into_owned!(path);
 
         Self::from_base_fn(move |base| base.get_node_as(&path))
     }
+
+    #[deprecated = "Renamed to `from_node`."]
+    pub fn node(path: impl AsArg<NodePath>) -> Self {
+        Self::from_node(path)
+    }
 }
 
 impl<T> OnReady<T> {

godot-macros/src/class/derive_godot_class.rs

@@ -563,8 +563,8 @@ fn parse_fields(
                     errors.push(error!(
                         parser.span(),
                         "The key `node` in attribute #[init] requires field of type `OnReady<T>`\n\
-				         Help: The syntax #[init(node = \"NodePath\")] is equivalent to \
-				         #[init(val = OnReady::node(\"NodePath\"))], \
+				         Hint: the syntax #[init(node = \"NodePath\")] is equivalent to \
+				         #[init(val = OnReady::from_node(\"NodePath\"))], \
 				         which can only be assigned to fields of type `OnReady<T>`"
                     ));
                 }
@@ -574,14 +574,14 @@ fn parse_fields(
                     errors.push(error!(
 				        parser.span(),
 				        "The key `node` in attribute #[init] is mutually exclusive with the keys `default` and `val`\n\
-				         Help: The syntax #[init(node = \"NodePath\")] is equivalent to \
-				         #[init(val = OnReady::node(\"NodePath\"))], \
+				         Hint: the syntax #[init(node = \"NodePath\")] is equivalent to \
+				         #[init(val = OnReady::from_node(\"NodePath\"))], \
 				         both aren't allowed since they would override each other"
 			        ));
                 }
 
                 let default_val = if is_well_formed {
-                    quote! { OnReady::node(#node_path) }
+                    quote! { OnReady::from_node(#node_path) }
                 } else {
                     quote! { todo!() }
                 };
@@ -607,7 +607,7 @@ fn parse_fields(
                     is_well_formed = false;
                     errors.push(error!(
 				        parser.span(),
-				        "The key `sentinel` in attribute #[init] is mutually exclusive with the keys `default` and `val`"
+				        "The key `sentinel` in attribute #[init] is mutually exclusive with the key `val`"
 			        ));
                 }