Struct rutie::RString

#[repr(C)]
pub struct RString { /* private fields */ }

String

Implementations

impl RString

pub fn new(string: &str) -> Self

👎Deprecated since 0.3.2: please use new_usascii_unchecked or new_utf8 instead

Creates a new instance of Ruby String containing given string.

Examples

use rutie::{RString, VM};

let string = RString::new("Hello, World!");

assert_eq!(string.to_str(), "Hello, World!");

Ruby:

str = 'Hello, World!'

str == 'Hello, World!'

pub fn new_utf8(string: &str) -> Self

Creates a new instance of Ruby String, with UTF8 encoding, containing given string.

Examples

use rutie::{RString, VM};

let string = RString::new_utf8("Hello, World!");

assert_eq!(string.to_string(), "Hello, World!".to_string());

Ruby:

str = 'Hello, World!'

str == 'Hello, World!'

pub fn new_usascii_unchecked(string: &str) -> Self

Creates a new instance of Ruby String containing given string.

Examples

use rutie::{RString, VM};

let string = RString::new_usascii_unchecked("Hello, World!");

assert_eq!(string.to_str(), "Hello, World!");

Ruby:

str = 'Hello, World!'

str == 'Hello, World!'

pub fn from_bytes(bytes: &[u8], enc: &Encoding) -> Self

Creates a new instance of Ruby String from given byte sequence with given Encoding.

Examples

use rutie::{RString, Encoding, EncodingSupport, VM};

let bytes = [197, 130, 97, 197, 130];
let enc = Encoding::find("UTF-8").unwrap();

let string = RString::from_bytes(&bytes, &enc);

assert_eq!(string.to_str(), "łał");

VM::require("enc/encdb");
VM::require("enc/trans/transdb");

let result = string.encode(Encoding::find("UTF-16").unwrap(), None);

assert_eq!(result.to_bytes_unchecked(), [254, 255, 1, 66, 0, 97, 1, 66])

pub fn to_string(&self) -> String

Retrieves underlying Rust String from Ruby String object.

Examples

use rutie::{RString, VM};

let string = RString::new_utf8("Hello, World!");

assert_eq!(string.to_string(), "Hello, World!".to_string());

Ruby:

str = 'Hello, World!'

str == 'Hello, World!'

pub fn to_string_unchecked(&self) -> String

Retrieves underlying Rust String from Ruby String object.

Unlike to_string() it does not perform any checks for internal null-bytes.

This function may be used to safely get binary data from Ruby.

Examples

use rutie::{RString, VM};

let string = RString::new_utf8("Hello,\0World!");

assert_eq!(string.to_string_unchecked(), "Hello,\0World!".to_string());

Ruby:

str = 'Hello,\0World!'

str == 'Hello,\0World!'

pub fn to_vec_u8_unchecked(&self) -> Vec<u8>

Retrieves Vec<u8> from Ruby String object.

Unlike to_string() it does not perform any checks for internal null-bytes.

This function may be used to safely get binary data from Ruby.

Examples

use rutie::{RString, VM};

let string = RString::new_utf8("Hello,\0World!");

assert_eq!(string.to_vec_u8_unchecked(), (b"Hello,\0World!").to_vec());

pub fn to_str(&self) -> &str

Retrieves underlying &str from Ruby String object.

Examples

use rutie::{RString, VM};

let string = RString::new_utf8("Hello, World!");

assert_eq!(string.to_str(), "Hello, World!");

Ruby:

str = 'Hello, World!'

str == 'Hello, World!'

pub fn to_str_unchecked(&self) -> &str

Retrieves underlying &str from Ruby String object.

Unlike to_str() it does not perform any checks for internal null-bytes.

This function may be used to safely get binary data from Ruby.

Examples

use rutie::{RString, VM};

let string = RString::new_utf8("Hello,\0World!");

assert_eq!(string.to_str_unchecked(), "Hello,\0World!");

Ruby:

str = 'Hello,\0World!'

str == 'Hello,\0World!'

pub fn to_bytes_unchecked(&self) -> &[u8]

Retrieves underlying &[u8] from Ruby String object.

Unlike to_str() it does not perform any checks for internal null-bytes.

This function may be used to safely get binary data from Ruby.

Examples

use rutie::{RString, VM};

let string = RString::new_utf8("Hello,\0World!");

assert_eq!(string.to_bytes_unchecked(), b"Hello,\0World!");

pub fn codepoints(&self) -> Array

Returns an array of each characters codepoints. This is useful as a strings encoding determines where the codepoints are.

Examples

use rutie::{Object, RString, Array, Fixnum, Encoding, EncodingSupport, VM};
VM::require("enc/encdb");
VM::require("enc/trans/transdb");

let string = RString::from_bytes(b"foo\x93_a", &Encoding::find("cp932").unwrap());

let codepoints: Array = [102, 111, 111, 37727, 97].
  into_iter().map(|cp| Fixnum::new(cp as i64).to_any_object()).collect();

assert!(string.codepoints().equals(&codepoints), "not equal!");

Ruby:

str = "foo\x93_a".force_encoding("cp932")

str.codepoints == [102, 111, 111, 37727, 97]

pub fn bytesize(&self) -> i64

Returns the length of the string in bytes

Examples

use rutie::{RString, VM};

let string = RString::new_utf8("Hello, World!");
let utf8_string = RString::new_utf8("⓯");

assert_eq!(string.bytesize(), 13);
assert_eq!(utf8_string.bytesize(), 3);

Ruby:

string = 'Hello, World!'
utf8_string = '⓯'

string.bytesize == 13
utf8_string.bytesize == 3

pub fn count_chars(&self) -> i64

Returns the number of characters in the string

Examples

use rutie::{RString, VM};

let string = RString::new_utf8("Hello, World!");
let utf8_string = RString::new_utf8("⓯");

assert_eq!(string.count_chars(), 13);
assert_eq!(utf8_string.count_chars(), 1);

Ruby:

string = 'Hello, World!'
utf8_string = '⓯'

string.length == 13
utf8_string.length == 1

pub fn concat(&mut self, string: &str)

Appends a given string slice onto the end of this String.

Examples

use rutie::{RString, VM};

let mut string = RString::new_utf8("Hello, ");
string.concat("World!");

assert_eq!(string.to_string(), "Hello, World!".to_string());

Ruby:

str = 'Hello, '
str << 'World!'

str == 'Hello, World!'

Trait Implementations

impl Debug for RString

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl EncodingSupport for RString

fn encoding(&self) -> Encoding

Get the strings Encoding.

Examples

use rutie::{RString, VM, EncodingSupport};

let string = RString::new_utf8("Hello");
string.encoding();

Ruby:

string = "Hello"
string.encoding()

fn force_encoding(&mut self, enc: Encoding) -> Result<Self, AnyException>

Changes the encoding to encoding and returns Result<Self, AnyException>.

Examples

use rutie::{RString, VM, EncodingSupport, Encoding};

let mut string = RString::new_utf8("Hello");
string.force_encoding(Encoding::us_ascii());

assert_eq!(string.encoding().name(), "US-ASCII");

Ruby:

string = "Hello"
string.force_encoding(Encoding::US_ASCII)

string.encoding.name == "US-ASCII"

use rutie::{RString, VM, EncodingSupport, Encoding, Object, Exception};

let mut string = RString::new_utf8("Hello");
string.force_encoding(Encoding::utf8());
string.freeze();
let result = string.force_encoding(Encoding::us_ascii());

match result {
    Ok(_) => assert_eq!("This is a bad path.", "You shouldn't get this message."),
    Err(happy_path) => assert_eq!(happy_path.message(), "can\'t modify frozen String"),
}

fn encode(&self, enc: Encoding, opts: Option<Hash>) -> Self

Transcodes to encoding and returns Self.

Examples

use rutie::{RString, VM, EncodingSupport, Encoding};

let mut string = RString::new_utf8("Hello");
let result = string.encode(Encoding::us_ascii(), None);

assert_eq!(result.encoding().name(), "US-ASCII");

Ruby:

string = "Hello"
result = string.encode(Encoding::US_ASCII)

result.encoding.name == "US-ASCII"

fn is_valid_encoding(&self) -> bool

Transcodes to encoding and returns Self.

Examples

use rutie::{RString, VM, EncodingSupport, Encoding, Object};

let mut string = RString::new_utf8("Hello");

assert!(string.is_valid_encoding(), "not valid encoding!");

VM::require("enc/encdb");
VM::require("enc/trans/transdb");

let result = VM::eval("'Hello'.force_encoding('UTF-32')").unwrap().
  try_convert_to::<RString>().unwrap();

assert!(!result.is_valid_encoding(), "is valid encoding!");

Ruby:

string = "Hello"

string.valid_encoding? == true

result = string.encode(Encoding::UTF_32)

result.valid_encoding? == false

fn compatible_with(&self, other: &impl Object) -> bool

Reveals if the given object has a compatible encoding with this String.

Examples

use rutie::{RString, VM, EncodingSupport};

let string1 = RString::new_utf8("Hello");
let string2 = RString::new_usascii_unchecked("Hello");

assert!(string1.compatible_with(&string2));

Ruby:

str1 = 'Hello'.force_encoding("UTF-8")
str2 = 'Hello'.force_encoding("US-ASCII")

str1 + str2 == "HelloHello"

fn compatible_encoding(obj1: &impl Object, obj2: &impl Object) -> AnyObject

Returns AnyObject of the compatible encoding between the two objects or nil if incompatible.

Examples

use rutie::{RString, VM, EncodingSupport};

let string1 = RString::new_utf8("Hello");
let string2 = RString::new_usascii_unchecked("Hello");

RString::compatible_encoding(&string1, &string2);

Ruby:

str1 = 'Hello'.force_encoding("UTF-8")
str2 = 'Hello'.force_encoding("US-ASCII")

begin
  (str1 + str2).encoding
rescue
  nil
end

impl From<&'static str> for RString

fn from(string: &'static str) -> Self

Converts to this type from the input type.

impl From<String> for RString

fn from(string: String) -> Self

Converts to this type from the input type.

impl From<Value> for RString

fn from(value: Value) -> Self

Converts to this type from the input type.

impl Into<AnyObject> for RString

fn into(self) -> AnyObject

Converts this type into the (usually inferred) input type.

impl Into<Value> for RString

fn into(self) -> Value

Converts this type into the (usually inferred) input type.

impl Object for RString

fn value(&self) -> Value

Returns internal value of current object.

fn class(&self) -> Class

Returns a class of current object.

fn singleton_class(&self) -> Class

Returns a singleton class of current object.

fn get_data<'a, T>(&'a self, wrapper: &'a dyn DataTypeWrapper<T>) -> &T

Gets an immutable reference to the Rust structure which is wrapped into a Ruby object.

fn get_data_mut<'a, T>( &'a mut self, wrapper: &'a dyn DataTypeWrapper<T> ) -> &mut T

Gets a mutable reference to the Rust structure which is wrapped into a Ruby object.

fn define<F: Fn(&mut Self)>(&mut self, f: F) -> &Self

Wraps calls to the object.

fn define_method<I: Object, O: Object>( &mut self, name: &str, callback: Callback<I, O> )

Defines an instance method for the given class or object.

fn define_private_method<I: Object, O: Object>( &mut self, name: &str, callback: Callback<I, O> )

Defines a private instance method for the given class or object.

fn define_singleton_method<I: Object, O: Object>( &mut self, name: &str, callback: Callback<I, O> )

Defines a class method for given class or singleton method for object.

fn def<I: Object, O: Object>(&mut self, name: &str, callback: Callback<I, O>)

An alias for define_method (similar to Ruby syntax def some_method).

fn def_private<I: Object, O: Object>( &mut self, name: &str, callback: Callback<I, O> )

An alias for define_private_method (similar to Ruby syntax private def some_method).

fn def_self<I: Object, O: Object>( &mut self, name: &str, callback: Callback<I, O> )

An alias for define_singleton_method (similar to Ruby def self.some_method).

unsafe fn send(&self, method: &str, arguments: &[AnyObject]) -> AnyObject

Calls a given method on an object similarly to Ruby Object#send method

fn equals<T: Object>(&self, other: &T) -> bool

Alias for Ruby’s ==

fn case_equals<T: Object>(&self, other: &T) -> bool

Alias for Ruby’s ===

fn is_eql<T: Object>(&self, other: &T) -> bool

Alias for Ruby’s eql?

fn is_equal<T: Object>(&self, other: &T) -> bool

Alias for Ruby’s equal?

fn respond_to(&self, method: &str) -> bool

Checks whether the object responds to given method

fn protect_send( &self, method: &str, arguments: &[AnyObject] ) -> Result<AnyObject, AnyException>

protect_send returns Result<AnyObject, AnyObject>

fn protect_public_send( &self, method: &str, arguments: &[AnyObject] ) -> Result<AnyObject, AnyException>

protect_public_send returns Result<AnyObject, AnyObject>

fn is_nil(&self) -> bool

Checks whether the object is nil

fn to_any_object(&self) -> AnyObject

Converts struct to AnyObject

fn instance_variable_get(&self, variable: &str) -> AnyObject

Gets an instance variable of object

fn instance_variable_set<T: Object>( &mut self, variable: &str, value: T ) -> AnyObject

Sets an instance variable for object

fn is_frozen(&self) -> bool

Returns the freeze status of the object.

fn freeze(&mut self) -> Self

Prevents further modifications to the object.

unsafe fn to<T: Object>(&self) -> T

Unsafely casts current object to the specified Ruby type

fn try_convert_to<T: VerifiedObject>(&self) -> Result<T, AnyException>

Safely casts current object to the specified Ruby type

fn ty(&self) -> ValueType

Determines the value type of the object

impl PartialEq for RString

fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl TryConvert<AnyObject> for RString

Implicit or nil conversion

Examples

use rutie::{RString, Fixnum, VM, TryConvert, NilClass, Object};

let four = Fixnum::new(4);
let result = RString::try_convert(four.to_any_object());

assert_eq!(result, Err(NilClass::new()));

let five = RString::new_utf8("5");
let result2 = RString::try_convert(five.to_any_object());

if let Ok(r) = result2 {
  assert_eq!(r.to_str(), "5")
} else {
  unreachable!()
}

Ruby:

four = 4
result = String.try_convert(four)

result == nil

five = "5"
result = String.try_convert(five)

result == "5"

type Nil = NilClass

The type returned in the event of a conversion error.

fn try_convert(obj: AnyObject) -> Result<Self, NilClass>

Performs the conversion.

impl VerifiedObject for RString

fn is_correct_type<T: Object>(object: &T) -> bool

fn error_message() -> &'static str