Implement GString::substr() with ranges

Author: Bromeon

godot-codegen/src/special_cases/special_cases.rs

@@ -241,7 +241,6 @@ pub fn is_builtin_method_exposed(builtin_ty: &TyName, godot_method_name: &str) -
         | ("String", "naturalnocasecmp_to")
         | ("String", "filecasecmp_to")
         | ("String", "filenocasecmp_to")
-        | ("String", "substr")
         | ("String", "get_slice")
         | ("String", "get_slicec")
         | ("String", "get_slice_count")
@@ -347,7 +346,6 @@ pub fn is_builtin_method_exposed(builtin_ty: &TyName, godot_method_name: &str) -
         | ("StringName", "naturalnocasecmp_to")
         | ("StringName", "filecasecmp_to")
         | ("StringName", "filenocasecmp_to")
-        | ("StringName", "substr")
         | ("StringName", "get_slice")
         | ("StringName", "get_slicec")
         | ("StringName", "get_slice_count")

godot-core/src/builtin/string/gstring.rs

@@ -5,8 +5,11 @@
  * file, You can obtain one at https://mozilla.org/MPL/2.0/.
  */
 
+use std::convert::Infallible;
+use std::ffi::c_char;
 use std::fmt::Write;
-use std::{convert::Infallible, ffi::c_char, fmt, str::FromStr};
+use std::str::FromStr;
+use std::{fmt, ops};
 
 use godot_ffi as sys;
 use sys::types::OpaqueString;
@@ -107,6 +110,13 @@ impl GString {
         }
     }
 
+    /// Returns a substring of this, as another `GString`.
+    pub fn substr(&self, range: impl ops::RangeBounds<usize>) -> Self {
+        let (from, len) = super::to_fromlen_pair(range);
+
+        self.as_inner().substr(from, len)
+    }
+
     /// Format a string using substitutions from an array or dictionary.
     ///
     /// See Godot's [`String.format()`](https://docs.godotengine.org/en/stable/classes/class_string.html#class-string-method-format).

godot-core/src/builtin/string/mod.rs

@@ -14,6 +14,7 @@ mod string_name;
 
 use crate::meta::error::ConvertError;
 use crate::meta::{FromGodot, GodotConvert, ToGodot};
+use std::ops;
 
 pub use gstring::*;
 pub use node_path::NodePath;
@@ -51,3 +52,25 @@ impl FromGodot for String {
         Ok(via.to_string())
     }
 }
+
+// ----------------------------------------------------------------------------------------------------------------------------------------------
+
+/// Returns a tuple of `(from, len)` from a Rust range.
+fn to_fromlen_pair<R>(range: R) -> (i64, i64)
+where
+    R: ops::RangeBounds<usize>,
+{
+    let from = match range.start_bound() {
+        ops::Bound::Included(&n) => n as i64,
+        ops::Bound::Excluded(&n) => (n as i64) + 1,
+        ops::Bound::Unbounded => 0,
+    };
+
+    let len = match range.end_bound() {
+        ops::Bound::Included(&n) => ((n + 1) as i64) - from,
+        ops::Bound::Excluded(&n) => (n as i64) - from,
+        ops::Bound::Unbounded => -1,
+    };
+
+    (from, len)
+}

godot-core/src/builtin/string/string_name.rs

@@ -5,7 +5,7 @@
  * file, You can obtain one at https://mozilla.org/MPL/2.0/.
  */
 
-use std::fmt;
+use std::{fmt, ops};
 
 use godot_ffi as sys;
 use sys::{ffi_methods, GodotFfi};
@@ -76,6 +76,16 @@ impl StringName {
             .expect("Godot hashes are uint32_t")
     }
 
+    // TODO unimplemented because it returns GString -- there must be an efficient way to substring interned string names?
+    /*
+    /// Returns a substring of this, as another `StringName`.
+    pub fn substr(&self, range: impl ops::RangeBounds<usize>) -> Self {
+        let (from, len) = super::from_len(range);
+
+        self.as_inner().substr(from, len)
+    }
+    */
+
     /// Format a string using substitutions from an array or dictionary.
     ///
     /// The result is `GString` and not `StringName`.

itest/rust/src/builtin_tests/string/gstring_test.rs

@@ -113,3 +113,14 @@ fn string_with_null() {
         assert_eq!(left, right);
     }
 }
+
+#[itest]
+fn string_substr() {
+    let string = GString::from("stable");
+    assert_eq!(string.substr(..), "stable".into());
+    assert_eq!(string.substr(1..), "table".into());
+    assert_eq!(string.substr(..4), "stab".into());
+    assert_eq!(string.substr(..=3), "stab".into());
+    assert_eq!(string.substr(2..5), "abl".into());
+    assert_eq!(string.substr(2..=4), "abl".into());
+}